@openclaw/clickclack 2026.10.1 → 2026.10.5-beta.1

package/dist/.setup/{channel-DI3hKiSg.mjs → channel-BFuhVeiX.mjs}

@@ -1,6 +1,6 @@
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { c as CLICKCLACK_CHANNEL_ID, d as DEFAULT_ACCOUNT_ID, f as isClickClackAccountCurrent, g as resolveClickClackAccountConfig, h as resolveClickClackAccount, l as clickClackConfigAdapter, m as listEnabledClickClackAccounts, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-DcF_7-VV.mjs";
-import { a as createClickClackClient, i as ClickClackHttpError, n as resolveChannelId, r as resolveWorkspaceId, s as normalizeClickClackCorrelationId } from "./resolve-DPtjHQHt.mjs";
+import { c as CLICKCLACK_CHANNEL_ID, d as DEFAULT_ACCOUNT_ID, f as isClickClackAccountCurrent, g as resolveClickClackAccountConfig, h as resolveClickClackAccount, l as clickClackConfigAdapter, m as listEnabledClickClackAccounts, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BJ5D55LV.mjs";
+import { a as createClickClackClient, i as ClickClackHttpError, n as resolveChannelId, r as resolveWorkspaceId, s as normalizeClickClackCorrelationId } from "./resolve-Br3ylpSz.mjs";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-CF7TKtkU.mjs";
 import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/account-helpers";
 import { parseDateStringTimestampMs } from "openclaw/plugin-sdk/number-runtime";
@@ -22,7 +22,7 @@ import { createAsyncLock } from "openclaw/plugin-sdk/async-lock-runtime";
 import { truncateCodePoints } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
-import { buildChannelInboundEventContext, createChannelInboundEnvelopeBuilder, createChannelPartialDeliveryError, recordChannelBotPairLoopAndCheckSuppression } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, createChannelInboundEnvelopeBuilderAsync, createChannelPartialDeliveryError, recordChannelBotPairLoopAndCheckSuppression } from "openclaw/plugin-sdk/channel-inbound";
 import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
 import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
@@ -174,61 +174,6 @@ async function hasPendingDiscussionOpenForDestination(params) {
 	return (await 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 slugifyLabel(label) {
-	return label.normalize("NFKD").replace(/[\u0300-\u036f]/gu, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 80).replace(/-+$/gu, "");
-}
-function fallbackDiscussionLabel(sessionKey, agentId) {
-	const agentSegment = agentId?.trim() ? slugifyLabel(agentId) : "";
-	const hash = shortSessionHash(sessionKey).slice(0, 8);
-	return `s-${agentSegment ? `${agentSegment}-` : ""}${hash}`;
-}
-function resolveDiscussionLabel(entry, sessionKey, agentId) {
-	return entry.label?.trim() || entry.displayName?.trim() || entry.subject?.trim() || fallbackDiscussionLabel(sessionKey, agentId);
-}
-function truncateDiscussionDisplayTitle(label) {
-	return truncateCodePoints(label, 200).trim();
-}
-function slugifyDiscussionLabel(label, sessionKey) {
-	return slugifyLabel(label) || 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, destinationIdentity, bindingGeneration) {
-	return `openclaw:${installationId}:${shortSessionHash([
-		mainSessionKey,
-		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 bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
 	const entry = runtime.agent.session.getSessionEntry({
@@ -237,6 +182,13 @@ function bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
 	});
 	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId && entry.archivedAt === void 0);
 }
+async function readDiscussionSessionEntry(runtime, sessionKey) {
+	const params = {
+		sessionKey,
+		readConsistency: "latest"
+	};
+	return runtime.agent.session.getSessionEntryAsync ? await runtime.agent.session.getSessionEntryAsync(params) : runtime.agent.session.getSessionEntry(params);
+}
 /**
 * Refresh the replaceable session attachment without changing the durable room identity.
 * The store registers persisted state before reindexing, so a failed write leaves the
@@ -259,6 +211,11 @@ function attachBindingToCurrentActiveSession(params) {
 }
 const DISCUSSION_BINDINGS_NAMESPACE = "discussion-bindings";
 const MAX_DISCUSSION_BINDINGS = 1e4;
+const BINDING_STORE_OPTIONS = {
+	namespace: DISCUSSION_BINDINGS_NAMESPACE,
+	maxEntries: MAX_DISCUSSION_BINDINGS,
+	overflowPolicy: "reject-new"
+};
 const MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS = 1e3;
 const storesByRuntime$1 = /* @__PURE__ */ new WeakMap();
 function channelKey(serverBaseUrl, channelId) {
@@ -267,31 +224,36 @@ function channelKey(serverBaseUrl, channelId) {
 /** SQLite-backed session/channel bindings with a process-local inbound lookup index. */
 var ClickClackDiscussionBindingStore = class {
 	#store;
+	#asyncStore;
 	#sessionByChannel = /* @__PURE__ */ new Map();
-	#mainByDiscussionSession = /* @__PURE__ */ new Map();
 	#detachedAtBySession = /* @__PURE__ */ new Map();
+	#channelBySession = /* @__PURE__ */ new Map();
 	#runtime;
+	#prepared = false;
+	#preparing;
+	#changedDuringPreparation = /* @__PURE__ */ new Set();
 	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);
+		this.#store = runtime.state.openSyncKeyedStore(BINDING_STORE_OPTIONS);
+	}
+	async prepare() {
+		if (!this.#prepared) await this.entries();
+	}
+	async getAsync(sessionKey) {
+		return await this.#workerStore().lookup(sessionKey);
 	}
 	get(sessionKey) {
 		return this.#store.lookup(sessionKey);
 	}
-	hasCapacity(sessionKey) {
-		return this.get(sessionKey) !== void 0 || this.count() < MAX_DISCUSSION_BINDINGS;
+	async hasCapacity(sessionKey) {
+		return await this.getAsync(sessionKey) !== void 0 || await this.countAsync() < 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) {
+		if (!binding || channelKey(binding.serverBaseUrl, binding.channelId) !== key) {
 			this.#sessionByChannel.delete(key);
 			return;
 		}
@@ -301,38 +263,43 @@ var ClickClackDiscussionBindingStore = class {
 		};
 	}
 	set(sessionKey, binding) {
-		const previous = this.get(sessionKey);
 		this.#store.register(sessionKey, binding);
-		if (previous) this.#unindex(sessionKey, previous);
+		if (!this.#prepared) this.#changedDuringPreparation.add(sessionKey);
+		this.#unindex(sessionKey);
 		this.#index(sessionKey, binding);
 	}
 	delete(sessionKey) {
-		const previous = this.get(sessionKey);
 		const deleted = this.#store.delete(sessionKey);
-		if (deleted && previous) this.#unindex(sessionKey, previous);
+		if (deleted && !this.#prepared) this.#changedDuringPreparation.add(sessionKey);
+		if (deleted) this.#unindex(sessionKey);
 		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) => ({
+	async entries() {
+		const load = async () => (await this.#workerStore().entries()).map((entry) => ({
 			sessionKey: entry.key,
 			binding: entry.value
 		}));
+		if (this.#prepared) return await load();
+		this.#preparing ??= load().then((entries) => {
+			for (const { sessionKey, binding } of entries) if (!this.#changedDuringPreparation.has(sessionKey)) this.#index(sessionKey, binding);
+			this.#prepared = true;
+			this.#changedDuringPreparation.clear();
+			return entries;
+		}).finally(() => {
+			this.#preparing = void 0;
+		});
+		return await this.#preparing;
 	}
-	count() {
-		return this.#store.count?.() ?? this.#store.entries().length;
+	async countAsync() {
+		const store = this.#workerStore();
+		return store.count ? await store.count() : (await this.entries()).length;
 	}
 	detachedCount() {
 		return this.#detachedAtBySession.size;
 	}
+	#workerStore() {
+		return this.#asyncStore ??= this.#runtime.state.openKeyedStore(BINDING_STORE_OPTIONS);
+	}
 	oldestDetached() {
 		let oldestSessionKey;
 		let oldestDetachedAt = Number.POSITIVE_INFINITY;
@@ -352,33 +319,15 @@ var ClickClackDiscussionBindingStore = class {
 		};
 	}
 	#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);
+		const channel = channelKey(binding.serverBaseUrl, binding.channelId);
+		this.#channelBySession.set(sessionKey, channel);
+		this.#sessionByChannel.set(channel, sessionKey);
 		if (binding.detachedAt !== void 0) this.#detachedAtBySession.set(sessionKey, binding.detachedAt);
 	}
-	#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);
+	#unindex(sessionKey) {
+		const channel = this.#channelBySession.get(sessionKey);
+		this.#channelBySession.delete(sessionKey);
+		if (channel) this.#sessionByChannel.delete(channel);
 		this.#detachedAtBySession.delete(sessionKey);
 	}
 };
@@ -390,6 +339,61 @@ function getClickClackDiscussionBindingStore(runtime) {
 	return created;
 }
 //#endregion
+//#region extensions/clickclack/src/discussions/naming.ts
+function shortSessionHash(sessionKey) {
+	return createHash("sha256").update(sessionKey).digest("hex").slice(0, 32);
+}
+function slugifyLabel(label) {
+	return label.normalize("NFKD").replace(/[\u0300-\u036f]/gu, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 80).replace(/-+$/gu, "");
+}
+function fallbackDiscussionLabel(sessionKey, agentId) {
+	const agentSegment = agentId?.trim() ? slugifyLabel(agentId) : "";
+	const hash = shortSessionHash(sessionKey).slice(0, 8);
+	return `s-${agentSegment ? `${agentSegment}-` : ""}${hash}`;
+}
+function resolveDiscussionLabel(entry, sessionKey, agentId) {
+	return entry.label?.trim() || entry.displayName?.trim() || entry.subject?.trim() || fallbackDiscussionLabel(sessionKey, agentId);
+}
+function truncateDiscussionDisplayTitle(label) {
+	return truncateCodePoints(label, 200).trim();
+}
+function slugifyDiscussionLabel(label, sessionKey) {
+	return slugifyLabel(label) || 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, destinationIdentity, bindingGeneration) {
+	return `openclaw:${installationId}:${shortSessionHash([
+		mainSessionKey,
+		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/eligibility.ts
 function discussionAccounts(cfg) {
 	return listEnabledClickClackAccounts(cfg).filter((account) => account.configured && account.discussions.enabled);
@@ -470,6 +474,7 @@ function isClickClackDiscussionChannelRevoked(params) {
 //#region extensions/clickclack/src/discussions/routing.ts
 async function resolveClickClackDiscussionRoute(params) {
 	const store = getClickClackDiscussionBindingStore(params.runtime);
+	await store.prepare();
 	let matched = store.getByChannel(params.serverBaseUrl, params.channelId);
 	let pending = false;
 	if (!matched) {
@@ -636,17 +641,14 @@ function parseClickClackTarget(raw) {
 	};
 	throw new Error(`Unsupported ClickClack target: ${raw}`);
 }
-/** Formats a parsed ClickClack target back into canonical target syntax. */
 function buildClickClackTarget(target) {
 	return `${target.kind}:${target.id}`;
 }
-/** Normalizes user-entered ClickClack target text for channel routing. */
 function normalizeClickClackTarget(raw) {
 	return buildClickClackTarget(parseClickClackTarget(raw));
 }
-/** Reports whether a target string can be offered to the ClickClack parser. */
 function looksLikeClickClackTarget(raw) {
-	return /^(channel|thread|dm):/i.test(raw.trim()) || raw.trim().length > 0;
+	return raw.trim().length > 0;
 }
 //#endregion
 //#region extensions/clickclack/src/access.ts
@@ -1017,7 +1019,6 @@ const STREAMING_COMMENTARY_ITEM_KINDS = /* @__PURE__ */ new Set([
 	"thinking",
 	"reasoning"
 ]);
-/** Provider-specific reasoning lanes normalized into one ClickClack label. */
 const THINKING_ITEM_KINDS = /* @__PURE__ */ new Set([
 	"analysis",
 	"thinking",
@@ -1043,9 +1044,7 @@ function activityBody(payload) {
 	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() || "";
+	return text || head || payload.status?.trim() || payload.kind?.trim() || "";
 }
 /**
 * Creates a per-turn activity publisher. Publishing is best-effort: transport
@@ -1078,7 +1077,7 @@ function createClickClackActivityPublisher(params) {
 			clearTimeout(segment.timer);
 			segment.timer = void 0;
 		}
-		if (!segment.dirty || !segment.body.trim()) return Promise.resolve();
+		if (!segment.dirty || !segment.body) return Promise.resolve();
 		segment.dirty = false;
 		const body = segment.body;
 		return enqueue(async () => {
@@ -1098,7 +1097,7 @@ function createClickClackActivityPublisher(params) {
 		const body = commentaryBody(payload);
 		const key = payload.itemId?.trim() || "turn";
 		let segment = commentaryByItem.get(key);
-		if (!body.trim()) {
+		if (!body) {
 			if (segment) {
 				clearTimeout(segment.timer);
 				commentaryByItem.delete(key);
@@ -1177,9 +1176,11 @@ function createClickClackActivityPublisher(params) {
 			handleDiscreteItem(payload);
 			return false;
 		},
+		/** Model/thinking from onModelSelected is stamped onto subsequent activity rows. */
 		setProvenance: (next) => {
 			provenance = next;
 		},
+		/** Flushes pending commentary and awaits all outstanding POST/PATCH work. */
 		finalize: async () => {
 			await flushAllCommentary();
 			await chain;
@@ -1258,25 +1259,16 @@ function createOutboundContext(params) {
 		cfg: params.cfg,
 		accountId: params.accountId
 	});
-	const assertDirectAdapterHandoff = params.assertDirectAdapterHandoff;
-	const fetcher = fetch;
 	return {
 		account,
 		client: createClickClackClient({
 			baseUrl: account.apiEndpoint,
 			token: account.token,
 			correlationId: params.correlationId,
-			fetch: assertDirectAdapterHandoff ? (input, init) => {
-				assertDirectAdapterHandoff();
-				return fetcher(input, init);
-			} : void 0
+			beforeRequest: params.assertDirectAdapterHandoff
 		})
 	};
 }
-/**
-* 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;
@@ -1793,10 +1785,10 @@ async function handleClickClackInbound(params) {
 		}
 	});
 	const senderName = message.author?.display_name || message.author_id;
-	const body = createChannelInboundEnvelopeBuilder({
+	const body = (await createChannelInboundEnvelopeBuilderAsync({
 		cfg: params.config,
 		route
-	})({
+	}))({
 		channel: "ClickClack",
 		from: senderName,
 		timestamp: new Date(message.created_at),
@@ -1939,9 +1931,6 @@ const CLICKCLACK_EVENT_PAGE_LIMIT = 500;
 function payloadString(event, key) {
 	return readStringField(event.payload, key) ?? "";
 }
-function eventCorrelationId(event) {
-	return normalizeClickClackCorrelationId(event.payload?.correlation_id);
-}
 async function resolveEventMessage(params) {
 	const messageId = payloadString(params.event, "message_id");
 	if (!messageId) return null;
@@ -1962,7 +1951,7 @@ function parseSocketEvent(data) {
 async function processEvent(params) {
 	if (params.event.type !== "message.created" && params.event.type !== "thread.reply_created") return;
 	if (params.abortSignal.aborted || payloadString(params.event, "author_id") === params.botUserId) return;
-	const correlationId = eventCorrelationId(params.event);
+	const correlationId = normalizeClickClackCorrelationId(params.event.payload?.correlation_id);
 	const message = await resolveEventMessage({
 		client: correlationId ? createClickClackClient({
 			baseUrl: params.account.apiEndpoint,
@@ -1998,17 +1987,17 @@ async function processEvent(params) {
 async function drainEventBacklog(params) {
 	let afterCursor = params.afterCursor;
 	while (!params.abortSignal.aborted) {
-		const events = (await params.client.eventPage(params.workspaceId, {
+		const page = await params.client.eventPage(params.workspaceId, {
 			afterCursor,
 			limit: CLICKCLACK_EVENT_PAGE_LIMIT
-		})).events;
-		for (const event of events) {
+		});
+		for (const event of page.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;
+		if (page.events.length === 0) return afterCursor;
 	}
 	return afterCursor;
 }
@@ -2334,4 +2323,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { slugifyDiscussionLabel as C, listPendingDiscussionOpens as D, clearPendingDiscussionOpen as E, recordPendingDiscussionOpen as O, resolveDiscussionLabel as S, clearDiscussionBindingGeneration as T, getClickClackDiscussionBindingStore as _, setClickClackRuntime as a, fallbackDiscussionLabel as b, markClickClackDiscussionChannelIdentityRevoked as c, discussionInfoForBinding as d, normalizedServerBaseUrl as f, bindingMatchesActiveSessionIncarnation as g, attachBindingToCurrentActiveSession as h, getClickClackRuntime as i, reserveDiscussionBindingGeneration as k, markClickClackDiscussionChannelRevoked as l, MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS as m, buildClickClackTarget as n, clearClickClackDiscussionChannelRevoked as o, resolveDiscussionBindingAccount as p, parseClickClackTarget as r, isClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, discussionAccounts as u, discussionCredentialFingerprint as v, truncateDiscussionDisplayTitle as w, isDiscussionSessionKey as x, discussionExternalRef as y };
+export { recordPendingDiscussionOpen as A, attachBindingToCurrentActiveSession as C, clearDiscussionBindingGeneration as D, readDiscussionSessionEntry as E, clearPendingDiscussionOpen as O, MAX_RETAINED_DETACHED_DISCUSSION_BINDINGS as S, getClickClackDiscussionBindingStore as T, fallbackDiscussionLabel as _, setClickClackRuntime as a, slugifyDiscussionLabel as b, markClickClackDiscussionChannelIdentityRevoked as c, discussionInfoForBinding as d, normalizedServerBaseUrl as f, discussionSessionKey as g, discussionExternalRef as h, getClickClackRuntime as i, reserveDiscussionBindingGeneration as j, listPendingDiscussionOpens as k, markClickClackDiscussionChannelRevoked as l, discussionCredentialFingerprint as m, buildClickClackTarget as n, clearClickClackDiscussionChannelRevoked as o, resolveDiscussionBindingAccount as p, parseClickClackTarget as r, isClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, discussionAccounts as u, isDiscussionSessionKey as v, bindingMatchesActiveSessionIncarnation as w, truncateDiscussionDisplayTitle as x, resolveDiscussionLabel as y };

package/dist/.setup/{resolve-DPtjHQHt.mjs → resolve-Br3ylpSz.mjs}

@@ -1,5 +1,6 @@
 import { createRequire } from "node:module";
 import { bufferToBlobPart } from "openclaw/plugin-sdk/blob-runtime";
+import { captureEffectAuthority } from "openclaw/plugin-sdk/fetch-runtime";
 import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
 import path from "node:path";
@@ -72,10 +73,13 @@ function createClickClackClient(options) {
 		const controller = requestOptions.timeoutMs !== void 0 && !init.signal ? new AbortController() : void 0;
 		const timeout = controller ? setTimeout(() => controller.abort(), requestOptions.timeoutMs) : void 0;
 		try {
-			const response = await fetcher(`${baseUrl}${path}`, {
-				...init,
-				...controller ? { signal: controller.signal } : {},
-				headers: requestHeaders
+			const response = await captureEffectAuthority().initiate(() => {
+				options.beforeRequest?.();
+				return fetcher(`${baseUrl}${path}`, {
+					...init,
+					...controller ? { signal: controller.signal } : {},
+					headers: requestHeaders
+				});
 			});
 			if (!response.ok) {
 				const detail = await readResponseTextLimited(response, CLICKCLACK_ERROR_BODY_LIMIT_BYTES);
@@ -132,6 +136,9 @@ function createClickClackClient(options) {
 			throw error;
 		}
 	}
+	function messageList(resource) {
+		return async (id, afterSeq, limit = 20) => requestObject("messages", `/api/${resource}/${encodeURIComponent(id)}/messages?after_seq=${afterSeq}&limit=${limit}`);
+	}
 	return {
 		me: async () => requestObject("user", "/api/me"),
 		setBotCommands: async (commands) => requestObject("bot_commands", "/api/bots/self/commands", {
@@ -148,7 +155,7 @@ function createClickClackClient(options) {
 			method: "PATCH",
 			body: JSON.stringify(patch)
 		}),
-		channelMessages: async (channelId, afterSeq, limit = 20) => requestObject("messages", `/api/channels/${encodeURIComponent(channelId)}/messages?after_seq=${afterSeq}&limit=${limit}`),
+		channelMessages: messageList("channels"),
 		latestChannelMessages: async (channelId, limit = 30) => {
 			const boundedLimit = Math.max(1, Math.min(CLICKCLACK_MESSAGE_PAGE_LIMIT, limit));
 			let beforeSeq;
@@ -191,7 +198,7 @@ function createClickClackClient(options) {
 				beforeSeq = page.oldest_seq;
 			}
 		},
-		directMessages: async (conversationId, afterSeq, limit = 20) => requestObject("messages", `/api/dms/${encodeURIComponent(conversationId)}/messages?after_seq=${afterSeq}&limit=${limit}`),
+		directMessages: messageList("dms"),
 		thread: async (messageId) => await request(`/api/messages/${encodeURIComponent(messageId)}/thread`),
 		message: async (messageId) => requestObject("message", `/api/messages/${encodeURIComponent(messageId)}`),
 		findMessageByNonce: async (params) => findByNonce("message", params),

package/dist/.setup/{runtime-api-Dm_MQHNq.mjs → runtime-api-hAV5Muz-.mjs}

@@ -1,6 +1,6 @@
-import { h as resolveClickClackAccount, p as listClickClackAccountIds } from "./setup-surface-DcF_7-VV.mjs";
-import { C as slugifyDiscussionLabel, D as listPendingDiscussionOpens, E as clearPendingDiscussionOpen, O as recordPendingDiscussionOpen, S as resolveDiscussionLabel, T as clearDiscussionBindingGeneration, _ as getClickClackDiscussionBindingStore, b as fallbackDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as bindingMatchesActiveSessionIncarnation, h as attachBindingToCurrentActiveSession, k as reserveDiscussionBindingGeneration, l as markClickClackDiscussionChannelRevoked, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionCredentialFingerprint, w as truncateDiscussionDisplayTitle, x as isDiscussionSessionKey, y as discussionExternalRef } from "./channel-DI3hKiSg.mjs";
-import { a as createClickClackClient, i as ClickClackHttpError, o as isClickClackChannelNameConflict, t as findClickClackWorkspace } from "./resolve-DPtjHQHt.mjs";
+import { h as resolveClickClackAccount, p as listClickClackAccountIds } from "./setup-surface-BJ5D55LV.mjs";
+import { A as recordPendingDiscussionOpen, C as attachBindingToCurrentActiveSession, D as clearDiscussionBindingGeneration, E as readDiscussionSessionEntry, O as clearPendingDiscussionOpen, T as getClickClackDiscussionBindingStore, _ as fallbackDiscussionLabel, b as slugifyDiscussionLabel, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as discussionSessionKey, h as discussionExternalRef, j as reserveDiscussionBindingGeneration, k as listPendingDiscussionOpens, l as markClickClackDiscussionChannelRevoked, m as discussionCredentialFingerprint, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as isDiscussionSessionKey, w as bindingMatchesActiveSessionIncarnation, x as truncateDiscussionDisplayTitle, y as resolveDiscussionLabel } from "./channel-BFuhVeiX.mjs";
+import { a as createClickClackClient, i as ClickClackHttpError, o as isClickClackChannelNameConflict, t as findClickClackWorkspace } from "./resolve-Br3ylpSz.mjs";
 import "../api.js";
 import { randomUUID } from "node:crypto";
 import { createAsyncLock } from "openclaw/plugin-sdk/async-lock-runtime";
@@ -36,15 +36,15 @@ var DetachedDiscussionBindingRetention = class {
 		this.#store.set(sessionKey, retained);
 		return retained;
 	}
-	ensureCapacity(sessionKey) {
-		while (!this.#store.hasCapacity(sessionKey)) if (!this.#pruneOldest()) throw new Error("ClickClack discussion binding capacity is exhausted");
+	async ensureCapacity(sessionKey) {
+		await this.#store.prepare();
+		while (!await this.#store.hasCapacity(sessionKey)) if (!this.#pruneOldest()) throw new Error("ClickClack discussion binding capacity is exhausted");
 	}
 	#pruneOldest() {
 		for (;;) {
 			const oldest = this.#store.oldestDetached();
 			if (!oldest) return false;
-			const current = this.#store.get(oldest.sessionKey);
-			if (!current || current.detachedAt === void 0) continue;
+			const current = oldest.binding;
 			if (this.#runtime.agent.session.getSessionEntry({
 				sessionKey: oldest.sessionKey,
 				readConsistency: "latest"
@@ -242,10 +242,7 @@ function assertManagedChannelListContract(channels) {
 }
 async function openClickClackDiscussionBinding(params) {
 	const { account, runtime, sessionKey, store } = params;
-	const entry = runtime.agent.session.getSessionEntry({
-		sessionKey,
-		readConsistency: "latest"
-	});
+	const entry = await readDiscussionSessionEntry(runtime, sessionKey);
 	if (!entry || entry.archivedAt !== void 0) return;
 	if (!entry.sessionId?.trim()) throw new Error("OpenClaw session does not yet have a concrete session id");
 	const client = params.clientFactory(account);
@@ -255,6 +252,12 @@ async function openClickClackDiscussionBinding(params) {
 	if (!workspace.route_id) throw new Error("ClickClack discussions workspace is missing its route id");
 	const serverBaseUrl = normalizedServerBaseUrl(account);
 	const credentialFingerprint = discussionCredentialFingerprint(account.token);
+	const revokeChannel = (channelId) => markClickClackDiscussionChannelIdentityRevoked({
+		runtime,
+		accountId: account.accountId,
+		serverBaseUrl,
+		channelId
+	});
 	const unresolved = (await listPendingDiscussionOpens(runtime)).find((pending) => pending.sessionKey === sessionKey);
 	if (unresolved && (unresolved.accountId !== account.accountId || unresolved.credentialFingerprint !== credentialFingerprint || unresolved.serverBaseUrl !== serverBaseUrl || unresolved.workspaceId !== workspace.id)) {
 		await params.reconcilePendingOpen(unresolved);
@@ -266,10 +269,16 @@ async function openClickClackDiscussionBinding(params) {
 		sessionKey
 	});
 	const fallback = fallbackDiscussionLabel(sessionKey, agentId);
-	const label = resolveDiscussionLabel(entry, sessionKey, agentId);
-	const displayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
-	const section = entry.category?.trim() || account.discussions.section;
-	const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? agentId, config.session?.mainKey, label);
+	const describeChannel = (session) => {
+		const label = resolveDiscussionLabel(session, sessionKey, agentId);
+		return {
+			label,
+			displayTitle: label === fallback ? "" : truncateDiscussionDisplayTitle(label),
+			section: session.category?.trim() || account.discussions.section,
+			externalUrl: controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? agentId, config.session?.mainKey, label)
+		};
+	};
+	const { label, displayTitle, section, externalUrl } = describeChannel(entry);
 	const assertCurrentAuthority = () => {
 		const currentAccounts = discussionAccounts(runtime.config.current());
 		const currentAccount = currentAccounts.length === 1 ? currentAccounts[0] : void 0;
@@ -278,9 +287,10 @@ async function openClickClackDiscussionBinding(params) {
 			readConsistency: "latest"
 		});
 		if (!currentAccount || currentAccount.accountId !== account.accountId || normalizedServerBaseUrl(currentAccount) !== serverBaseUrl || currentAccount.apiEndpoint !== account.apiEndpoint || discussionCredentialFingerprint(currentAccount.token) !== credentialFingerprint || currentAccount.discussions.workspace !== account.discussions.workspace || !currentEntry?.sessionId || currentEntry.archivedAt !== void 0) throw new Error("ClickClack discussion authority changed while opening the channel");
+		return currentEntry;
 	};
 	return await params.withChannelMutationLock(async () => {
-		params.ensureBindingCapacity(sessionKey);
+		await params.ensureBindingCapacity(sessionKey);
 		let channels = await client.channels(workspace.id);
 		assertManagedChannelListContract(channels);
 		const destinationIdentity = [serverBaseUrl, workspace.id].join("\0");
@@ -336,24 +346,14 @@ async function openClickClackDiscussionBinding(params) {
 			assertCurrentAuthority();
 			try {
 				if (adopted) {
-					markClickClackDiscussionChannelIdentityRevoked({
-						runtime,
-						accountId: account.accountId,
-						serverBaseUrl,
-						channelId: adopted.id
-					});
+					revokeChannel(adopted.id);
 					resolved = await client.updateChannel(adopted.id, managedFields);
 				} else {
 					resolved = await client.createChannel(workspace.id, {
 						...managedFields,
 						kind: "public"
 					});
-					markClickClackDiscussionChannelIdentityRevoked({
-						runtime,
-						accountId: account.accountId,
-						serverBaseUrl,
-						channelId: resolved.id
-					});
+					revokeChannel(resolved.id);
 				}
 				break;
 			} catch (error) {
@@ -369,12 +369,7 @@ async function openClickClackDiscussionBinding(params) {
 					const recovered = relisted.find((candidate) => candidate.external_managed === true && candidate.external_ref === externalRef);
 					if (recovered) {
 						adopted = recovered;
-						markClickClackDiscussionChannelIdentityRevoked({
-							runtime,
-							accountId: account.accountId,
-							serverBaseUrl,
-							channelId: recovered.id
-						});
+						revokeChannel(recovered.id);
 						assertCurrentAuthority();
 						resolved = await client.updateChannel(recovered.id, managedFields);
 						break;
@@ -407,19 +402,14 @@ async function openClickClackDiscussionBinding(params) {
 			throw new Error("ClickClack discussion channel is missing its route id");
 		}
 		const channel = resolved;
-		const currentEntry = runtime.agent.session.getSessionEntry({
-			sessionKey,
-			readConsistency: "latest"
-		});
+		const currentEntry = await readDiscussionSessionEntry(runtime, sessionKey);
 		if (!currentEntry?.sessionId || currentEntry.archivedAt !== void 0) {
 			await clearPendingDiscussionOpen(generationScope);
 			params.warn(`unattached discussion channel remains quarantined: ${channel.id}`);
 			throw new Error("OpenClaw session became inactive while opening its ClickClack discussion");
 		}
-		const currentLabel = resolveDiscussionLabel(currentEntry, sessionKey, agentId);
-		const currentDisplayTitle = currentLabel === fallback ? "" : truncateDiscussionDisplayTitle(currentLabel);
-		const currentSection = currentEntry.category?.trim() || account.discussions.section;
-		const currentExternalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? agentId, config.session?.mainKey, currentLabel) ?? "";
+		const { label: currentLabel, displayTitle: currentDisplayTitle, section: currentSection, externalUrl: updatedExternalUrl } = describeChannel(currentEntry);
+		const currentExternalUrl = updatedExternalUrl ?? "";
 		let currentChannel = channel;
 		if (currentEntry.sessionId !== entry.sessionId || currentLabel !== label || currentDisplayTitle !== displayTitle || currentSection !== section || currentExternalUrl !== (externalUrl ?? "")) try {
 			currentChannel = await renameDiscussionChannel({
@@ -461,7 +451,7 @@ async function openClickClackDiscussionBinding(params) {
 			...currentChannel.display_title !== void 0 ? { displayTitle: currentChannel.display_title } : {}
 		};
 		try {
-			assertCurrentAuthority();
+			nextBinding.sessionId = assertCurrentAuthority().sessionId;
 			store.set(sessionKey, nextBinding);
 		} catch (error) {
 			await clearPendingDiscussionOpen(generationScope);
@@ -474,7 +464,7 @@ async function openClickClackDiscussionBinding(params) {
 }
 async function reconcilePendingDiscussionOpen(params) {
 	const { pending } = params;
-	const currentBinding = params.store.get(pending.sessionKey);
+	const currentBinding = await params.store.getAsync(pending.sessionKey);
 	if (currentBinding?.externalRef === pending.externalRef) {
 		await params.finalizePendingBinding(pending.sessionKey, currentBinding);
 		return;
@@ -486,10 +476,7 @@ async function reconcilePendingDiscussionOpen(params) {
 	})).find((candidate) => candidate.configured && normalizedServerBaseUrl(candidate) === pending.serverBaseUrl && discussionCredentialFingerprint(candidate.token) === pending.credentialFingerprint);
 	if (!account) return;
 	const client = params.clientFactory(account);
-	const entry = params.runtime.agent.session.getSessionEntry({
-		sessionKey: pending.sessionKey,
-		readConsistency: "latest"
-	});
+	const entry = await readDiscussionSessionEntry(params.runtime, pending.sessionKey);
 	const activeAccounts = discussionAccounts(cfg);
 	const retryAccount = activeAccounts.length === 1 ? activeAccounts[0] : void 0;
 	if (params.allowRetry !== false && entry?.sessionId && entry.archivedAt === void 0 && retryAccount && normalizedServerBaseUrl(retryAccount) === pending.serverBaseUrl && discussionCredentialFingerprint(retryAccount.token) === pending.credentialFingerprint) {
@@ -559,8 +546,8 @@ var ClickClackDiscussionService = class {
 		});
 		this.provider = {
 			id: "clickclack",
-			info: async ({ sessionKey }) => await this.info(sessionKey),
-			open: async ({ sessionKey }) => await this.open(sessionKey)
+			info: ({ sessionKey }) => this.info(sessionKey),
+			open: ({ sessionKey }) => this.open(sessionKey)
 		};
 	}
 	async bindGatewayEvents(gatewayEvents, scheduler) {
@@ -580,7 +567,7 @@ var ClickClackDiscussionService = class {
 		});
 		this.#unsubscribeSessionsChanged = gatewayEvents?.onSessionsChanged((event) => {
 			this.#withOperation(async () => {
-				if (this.#store.get(event.sessionKey) || (await listPendingDiscussionOpens(this.#runtime)).some((pending) => pending.sessionKey === event.sessionKey)) {
+				if (await this.#store.getAsync(event.sessionKey) || (await listPendingDiscussionOpens(this.#runtime)).some((pending) => pending.sessionKey === event.sessionKey)) {
 					if (activation === this.#activation) this.#reconcileScheduler?.schedule(event.sessionKey);
 				}
 			}).catch((error) => {
@@ -600,8 +587,9 @@ var ClickClackDiscussionService = class {
 	}
 	async info(sessionKey) {
 		return await this.#withOperation(() => this.#sessionQueue.enqueue(sessionKey, async () => {
+			await this.#store.prepare();
 			if (discussionAccounts(this.#currentConfig()).length !== 1) return { state: "none" };
-			const existing = this.#store.get(sessionKey);
+			const existing = await this.#store.getAsync(sessionKey);
 			if (existing) {
 				const resolved = await this.#resolveBindingForUse(existing);
 				if (resolved.state === "retargeted") {
@@ -615,7 +603,7 @@ var ClickClackDiscussionService = class {
 				if (resolved.state !== "active") return { state: "none" };
 				await this.#finalizePendingBinding(sessionKey, existing);
 				await this.#reconcileBinding(sessionKey, existing, resolved.account);
-				const current = this.#store.get(sessionKey);
+				const current = await this.#store.getAsync(sessionKey);
 				if (!current) return { state: this.hasEnabledAccount() ? "available" : "none" };
 				return discussionInfoForBinding(current, resolved.account);
 			}
@@ -623,7 +611,10 @@ var ClickClackDiscussionService = class {
 		}));
 	}
 	async open(sessionKey) {
-		return await this.#withOperation(() => this.#sessionQueue.enqueue(sessionKey, () => this.#open(sessionKey)));
+		return await this.#withOperation(() => this.#sessionQueue.enqueue(sessionKey, async () => {
+			await this.#store.prepare();
+			return await this.#open(sessionKey);
+		}));
 	}
 	async #open(sessionKey) {
 		this.#installationId ??= await getClickClackDiscussionInstallationId(this.#runtime);
@@ -631,7 +622,7 @@ var ClickClackDiscussionService = class {
 		if (accounts.length > 1) throw new Error("ClickClack discussions require exactly one enabled discussion account");
 		const account = accounts[0];
 		if (!account) return { state: "none" };
-		const existing = this.#store.get(sessionKey);
+		const existing = await this.#store.getAsync(sessionKey);
 		if (existing) {
 			const resolved = await this.#resolveBindingForUse(existing);
 			if (resolved.state === "retargeted") this.#revokeAndDeleteBinding(sessionKey, existing);
@@ -639,7 +630,7 @@ var ClickClackDiscussionService = class {
 			else if (resolved.state === "active") {
 				await this.#finalizePendingBinding(sessionKey, existing);
 				await this.#reconcileBinding(sessionKey, existing, resolved.account);
-				const current = this.#store.get(sessionKey);
+				const current = await this.#store.getAsync(sessionKey);
 				if (current) return discussionInfoForBinding(current, resolved.account);
 			}
 		}
@@ -654,8 +645,8 @@ var ClickClackDiscussionService = class {
 				bindingGenerationFactory: this.#bindingGenerationFactory,
 				sessionKey,
 				ensureTimer: () => this.#ensureTimer(),
-				reconcilePendingOpen: async (pending) => await this.#reconcilePendingOpen(pending, { allowRetry: false }),
-				withChannelMutationLock: async (run) => await this.#withChannelMutationLock(run),
+				reconcilePendingOpen: (pending) => this.#reconcilePendingOpen(pending, { allowRetry: false }),
+				withChannelMutationLock: (run) => this.#withChannelMutationLock(run),
 				ensureBindingCapacity: (key) => this.#detachedBindings.ensureCapacity(key),
 				finalizePendingBinding: (key, nextBinding) => this.#finalizePendingBinding(key, nextBinding),
 				warn: (message) => this.#logger().warn(message)
@@ -672,7 +663,8 @@ var ClickClackDiscussionService = class {
 	async #reconcile(sessionKey) {
 		try {
 			await this.#sessionQueue.enqueue(sessionKey, async () => {
-				const binding = this.#store.get(sessionKey);
+				await this.#store.prepare();
+				const binding = await this.#store.getAsync(sessionKey);
 				if (binding) await this.#reconcileBinding(sessionKey, binding);
 				const pending = (await listPendingDiscussionOpens(this.#runtime)).find((candidate) => candidate.sessionKey === sessionKey);
 				if (pending) await this.#reconcilePendingOpen(pending);
@@ -702,7 +694,8 @@ var ClickClackDiscussionService = class {
 	}
 	async readLatestMessages(sessionKey, limit) {
 		return await this.#withOperation(() => this.#sessionQueue.enqueue(sessionKey, async () => {
-			const binding = this.#store.get(sessionKey);
+			await this.#store.prepare();
+			const binding = await this.#store.getAsync(sessionKey);
 			if (!binding) return { text: "No discussion is bound to this session." };
 			const resolved = await this.#resolveBindingForUse(binding);
 			if (resolved.state !== "active") return { text: "No discussion is bound to this session." };
@@ -759,10 +752,31 @@ var ClickClackDiscussionService = class {
 			return;
 		}
 		if (resolved.state !== "active") return;
-		const account = resolved.account;
-		if (!account.baseUrl || !account.token) throw new Error(`ClickClack discussion account is no longer configured: ${activeBinding.accountId}`);
+		if (!resolved.account.baseUrl || !resolved.account.token) throw new Error(`ClickClack discussion account is no longer configured: ${activeBinding.accountId}`);
 		if (entry.archivedAt !== void 0) return;
-		const attached = this.#refreshSessionAttachment(sessionKey, activeBinding);
+		const labelForBackfill = resolveDiscussionLabel(entry, sessionKey, activeBinding.agentId);
+		const desiredBackfillTitle = labelForBackfill === fallbackDiscussionLabel(sessionKey, activeBinding.agentId) ? "" : truncateDiscussionDisplayTitle(labelForBackfill);
+		let bindingForAttachment = activeBinding;
+		let observedSiblingTitleSupport = false;
+		if (labelForBackfill === activeBinding.label && desiredBackfillTitle !== "" && activeBinding.displayTitle === void 0) {
+			const bindings = await this.#store.entries();
+			const freshBinding = this.#store.get(sessionKey);
+			if (!freshBinding || freshBinding.serverBaseUrl !== activeBinding.serverBaseUrl || freshBinding.channelId !== activeBinding.channelId || freshBinding.externalRef !== activeBinding.externalRef) return;
+			if (isClickClackDiscussionChannelRevoked({
+				runtime: this.#runtime,
+				serverBaseUrl: freshBinding.serverBaseUrl,
+				channelId: freshBinding.channelId
+			})) {
+				this.#store.delete(sessionKey);
+				return;
+			}
+			bindingForAttachment = freshBinding;
+			observedSiblingTitleSupport = bindings.some(({ binding: candidate }) => candidate.displayTitle !== void 0 && candidate.serverBaseUrl === freshBinding.serverBaseUrl && candidate.accountId === freshBinding.accountId);
+		}
+		const current = resolveDiscussionBindingAccount(this.#currentConfig(), bindingForAttachment);
+		if (current.state !== "active") return;
+		const account = current.account;
+		const attached = this.#refreshSessionAttachment(sessionKey, bindingForAttachment);
 		if (!attached) return;
 		const currentBinding = attached;
 		const fallback = fallbackDiscussionLabel(sessionKey, currentBinding.agentId);
@@ -772,7 +786,7 @@ var ClickClackDiscussionService = class {
 		const patch = {};
 		const labelChanged = label !== currentBinding.label;
 		const desiredDisplayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
-		const serverSupportsDisplayTitle = this.#store.entries().some(({ binding: candidate }) => candidate.displayTitle !== void 0 && candidate.serverBaseUrl === currentBinding.serverBaseUrl && candidate.accountId === currentBinding.accountId);
+		const serverSupportsDisplayTitle = currentBinding.displayTitle !== void 0 || observedSiblingTitleSupport;
 		const shouldBackfillDisplayTitle = desiredDisplayTitle !== "" && currentBinding.displayTitle !== desiredDisplayTitle && serverSupportsDisplayTitle;
 		if (labelChanged || shouldBackfillDisplayTitle) patch.display_title = desiredDisplayTitle;
 		if (section !== currentBinding.section) patch.sidebar_section = section;
@@ -870,7 +884,7 @@ var ClickClackDiscussionService = class {
 	async #ensureTimer() {
 		if (this.#closed) return;
 		const hasPendingOpens = (await listPendingDiscussionOpens(this.#runtime)).length > 0;
-		const needsBindingPoll = this.#unsubscribeSessionsChanged === void 0 && this.#store.count() > 0;
+		const needsBindingPoll = this.#unsubscribeSessionsChanged === void 0 && await this.#store.countAsync() > 0;
 		if (this.#closed || !hasPendingOpens && !needsBindingPoll) {
 			if (this.#timer) {
 				this.#timer.cancel();
@@ -889,7 +903,7 @@ var ClickClackDiscussionService = class {
 		});
 	}
 	async #listReconcileSessionKeys() {
-		return /* @__PURE__ */ new Set([...this.#store.entries().map(({ sessionKey }) => sessionKey), ...(await listPendingDiscussionOpens(this.#runtime)).map(({ sessionKey }) => sessionKey)]);
+		return /* @__PURE__ */ new Set([...(await this.#store.entries()).map(({ sessionKey }) => sessionKey), ...(await listPendingDiscussionOpens(this.#runtime)).map(({ sessionKey }) => sessionKey)]);
 	}
 	#logger() {
 		return this.#runtime.logging.getChildLogger({
@@ -919,30 +933,42 @@ function blockedResult() {
 	};
 }
 function isClickClackDiscussionSessionTarget(params) {
-	const matched = getClickClackDiscussionBindingStore(params.runtime).getByDiscussionSession(params.requesterSessionKey);
-	if (matched && matched.sessionKey === params.targetSessionKey && !isClickClackDiscussionChannelRevoked({
-		runtime: params.runtime,
-		serverBaseUrl: matched.binding.serverBaseUrl,
-		channelId: matched.binding.channelId
-	}) && bindingMatchesActiveSessionIncarnation(params.runtime, matched.sessionKey, matched.binding) && resolveDiscussionBindingAccount(params.runtime.config.current(), matched.binding).state === "active") return matched;
+	if (!isDiscussionSessionKey(params.requesterSessionKey)) return;
+	const { runtime, targetSessionKey } = params;
+	let binding;
+	try {
+		binding = getClickClackDiscussionBindingStore(runtime).get(targetSessionKey);
+	} catch {
+		return;
+	}
+	if (binding && discussionSessionKey({
+		runtime,
+		mainSessionKey: targetSessionKey,
+		...binding
+	}) === params.requesterSessionKey && !isClickClackDiscussionChannelRevoked({
+		runtime,
+		serverBaseUrl: binding.serverBaseUrl,
+		channelId: binding.channelId
+	}) && bindingMatchesActiveSessionIncarnation(runtime, targetSessionKey, binding) && resolveDiscussionBindingAccount(runtime.config.current(), binding).state === "active") return {
+		sessionKey: targetSessionKey,
+		binding
+	};
 }
 /** Restricts a discussion side session's session tools to its attached main session. */
 function enforceClickClackDiscussionToolTarget(params) {
 	const callerSessionKey = params.context.sessionKey;
-	if (!callerSessionKey) return;
+	if (!callerSessionKey || !isDiscussionSessionKey(callerSessionKey)) return;
 	const { toolName } = params.event;
 	if (toolName !== "session_status" && !toolName.startsWith("sessions_")) return;
-	const matched = getClickClackDiscussionBindingStore(params.runtime).getByDiscussionSession(callerSessionKey);
-	if (!matched) return isDiscussionSessionKey(callerSessionKey) ? blockedResult() : void 0;
-	const targetsMain = Boolean(isClickClackDiscussionSessionTarget({
-		runtime: params.runtime,
-		requesterSessionKey: callerSessionKey,
-		targetSessionKey: matched.sessionKey
-	})) && TARGETED_SESSION_TOOLS.has(toolName) && params.event.params.sessionKey === matched.sessionKey;
 	const usesAlternateSendTarget = toolName === "sessions_send" && (params.event.params.label !== void 0 || params.event.params.agentId !== void 0);
 	const mutatesStatus = toolName === "session_status" && params.event.params.model !== void 0;
 	const selectsHistoryIncarnation = toolName === "sessions_history" && params.event.params.sessionId !== void 0;
-	if (targetsMain && !usesAlternateSendTarget && !mutatesStatus && !selectsHistoryIncarnation) return;
+	const targetSessionKey = params.event.params.sessionKey;
+	if (TARGETED_SESSION_TOOLS.has(toolName) && typeof targetSessionKey === "string" && !usesAlternateSendTarget && !mutatesStatus && !selectsHistoryIncarnation && isClickClackDiscussionSessionTarget({
+		runtime: params.runtime,
+		requesterSessionKey: callerSessionKey,
+		targetSessionKey
+	})) return;
 	return blockedResult();
 }
 //#endregion

package/dist/.setup/{setup-claim-Cfv5ikVH.mjs → setup-claim-C-9Pvumz.mjs}

@@ -1,4 +1,4 @@
-import { a as isClickClackSetupLoopbackHost, i as buildClickClackSetupClaimUrl, o as requireClickClackSetupApiBaseUrl } from "./setup-surface-DcF_7-VV.mjs";
+import { a as isClickClackSetupLoopbackHost, i as buildClickClackSetupClaimUrl, o as requireClickClackSetupApiBaseUrl } from "./setup-surface-BJ5D55LV.mjs";
 import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createProviderOperationDeadline, readProviderJsonResponse, readResponseTextLimited, resolveProviderOperationTimeoutMs } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithSsrFGuard, resolvePinnedHostnameWithPolicy, ssrfPolicyFromHttpBaseUrlAllowedHostname } from "openclaw/plugin-sdk/ssrf-runtime";
@@ -70,13 +70,8 @@ function parseClickClackSetupCodeClaim(value, expectedClaimUrl) {
 }
 /** Claims a one-time setup code without sending any existing bot credential. */
 async function claimClickClackSetupCode(params) {
-	let parsedClaimUrl;
-	try {
-		parsedClaimUrl = new URL(params.claimUrl);
-	} catch {
-		throw new Error("ClickClack setup code claim URL must be a valid HTTP(S) endpoint.");
-	}
-	if (parsedClaimUrl.protocol !== "http:" && parsedClaimUrl.protocol !== "https:" || parsedClaimUrl.username || parsedClaimUrl.password || parsedClaimUrl.search || parsedClaimUrl.hash || !parsedClaimUrl.pathname.endsWith("/api/bot-setup-codes/claim")) throw new Error("ClickClack setup code claim URL must be a valid HTTP(S) endpoint.");
+	const parsedClaimUrl = URL.parse(params.claimUrl);
+	if (!parsedClaimUrl || parsedClaimUrl.protocol !== "http:" && parsedClaimUrl.protocol !== "https:" || parsedClaimUrl.username || parsedClaimUrl.password || parsedClaimUrl.search || parsedClaimUrl.hash || !parsedClaimUrl.pathname.endsWith("/api/bot-setup-codes/claim")) throw new Error("ClickClack setup code claim URL must be a valid HTTP(S) endpoint.");
 	const deadline = createProviderOperationDeadline({
 		label: "ClickClack setup code claim",
 		timeoutMs: CLICKCLACK_SETUP_CODE_CLAIM_TIMEOUT_MS

package/dist/.setup/setup-plugin-api-DpKXmzV1.mjs

@@ -0,0 +1,2 @@
+import { t as clickClackSetupPlugin } from "./setup-plugin-api-Qi8u_lra.mjs";
+export { clickClackSetupPlugin };

package/dist/.setup/{setup-plugin-api-CqfAb-CU.mjs → setup-plugin-api-Qi8u_lra.mjs}

@@ -1,4 +1,4 @@
-import { l as clickClackConfigAdapter, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-DcF_7-VV.mjs";
+import { l as clickClackConfigAdapter, n as clickClackSetupContract, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-BJ5D55LV.mjs";
 //#region extensions/clickclack/src/channel.setup.ts
 const clickClackSetupPlugin = {
 	id: "clickclack",

package/dist/.setup/{setup-surface-DcF_7-VV.mjs → setup-surface-BJ5D55LV.mjs}

@@ -232,9 +232,6 @@ const clickClackConfigAdapter = {
 };
 //#endregion
 //#region extensions/clickclack/src/config-schema.ts
-/**
-* Zod-backed config schema for ClickClack channel accounts.
-*/
 const ClickClackAccountConfigSchema = z.object({
 	name: z.string().optional(),
 	enabled: z.boolean().optional(),
@@ -315,13 +312,8 @@ function isClickClackSetupLoopbackHost(hostname) {
 }
 function requireClickClackSetupApiBaseUrl(value, label) {
 	if (!value || value !== value.trim()) throw new Error(`ClickClack ${label} is invalid`);
-	let parsed;
-	try {
-		parsed = new URL(value);
-	} catch {
-		throw new Error(`ClickClack ${label} is invalid`);
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || !parsed.hostname || parsed.hostname.endsWith(".") || parsed.username || parsed.password || parsed.search || parsed.hash) throw new Error(`ClickClack ${label} is invalid`);
+	const parsed = URL.parse(value);
+	if (!parsed || parsed.protocol !== "http:" && parsed.protocol !== "https:" || !parsed.hostname || parsed.hostname.endsWith(".") || parsed.username || parsed.password || parsed.search || parsed.hash) throw new Error(`ClickClack ${label} is invalid`);
 	if (parsed.protocol === "http:" && !isClickClackSetupLoopbackHost(parsed.hostname)) throw new Error(`ClickClack ${label} must use HTTPS unless it is on loopback`);
 	const pathname = parsed.pathname;
 	let basePath = "";
@@ -334,13 +326,8 @@ function requireClickClackSetupApiBaseUrl(value, label) {
 	return canonical;
 }
 function requireClickClackSetupClaimUrl(value) {
-	let parsed;
-	try {
-		parsed = new URL(value);
-	} catch {
-		throw new Error("ClickClack setup URL has an invalid claim endpoint.");
-	}
-	if (parsed.username || parsed.password || parsed.search || parsed.hash || !parsed.pathname.endsWith("/api/bot-setup-codes/claim")) throw new Error("ClickClack setup URL has an invalid claim endpoint.");
+	const parsed = URL.parse(value);
+	if (!parsed || parsed.username || parsed.password || parsed.search || parsed.hash || !parsed.pathname.endsWith("/api/bot-setup-codes/claim")) throw new Error("ClickClack setup URL has an invalid claim endpoint.");
 	const basePath = parsed.pathname.slice(0, -26);
 	const apiBaseUrl = requireClickClackSetupApiBaseUrl(parsed.origin + basePath, "setup URL API base");
 	const claimUrl = apiBaseUrl + CLICKCLACK_SETUP_CODE_CLAIM_PATH;
@@ -362,15 +349,9 @@ const REQUIRED_INPUT_ERROR = "ClickClack requires --token, --base-url, and --wor
 const INVALID_BASE_URL_ERROR = "ClickClack base URL must be a valid http(s) URL.";
 const SETUP_CODE_CONFLICT_ERROR = "ClickClack --code cannot be combined with --token, --token-file, or --use-env.";
 function normalizeClickClackBaseUrl(value) {
-	const trimmed = value?.trim();
-	if (!trimmed) return;
-	try {
-		const parsed = new URL(trimmed);
-		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
-		return parsed.toString().replace(/\/+$/, "");
-	} catch {
-		return;
-	}
+	const parsed = URL.parse(value?.trim() ?? "");
+	if (!parsed || parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+	return parsed.toString().replace(/\/+$/, "");
 }
 function normalizeClickClackSetupCode(value) {
 	const normalized = value.trim().toUpperCase().replaceAll("-", "").replaceAll(" ", "");
@@ -389,12 +370,8 @@ function parseClickClackSetupCodeInput(params) {
 	let baseUrl;
 	let exactClaimUrl;
 	if (/^[a-z][a-z\d+.-]*:\/\//iu.test(rawCode)) {
-		let setupUrl;
-		try {
-			setupUrl = new URL(rawCode);
-		} catch {
-			throw new Error("ClickClack --code must be a valid HTTP(S) setup URL or a bare setup code.");
-		}
+		const setupUrl = URL.parse(rawCode);
+		if (!setupUrl) throw new Error("ClickClack --code must be a valid HTTP(S) setup URL or a bare setup code.");
 		if (setupUrl.protocol !== "http:" && setupUrl.protocol !== "https:") throw new Error("ClickClack setup codes require an HTTP(S) URL.");
 		if (setupUrl.username || setupUrl.password) throw new Error("ClickClack setup URLs must not include credentials.");
 		if (setupUrl.search) throw new Error("ClickClack setup URLs must not include a query.");
@@ -473,7 +450,7 @@ const clickClackSetupAdapter = {
 		const claimUrl = setup.exactClaimUrl && !privateApiBaseUrl ? setup.exactClaimUrl : buildClickClackSetupClaimUrl(privateApiBaseUrl ?? setup.baseUrl);
 		let claim;
 		try {
-			const { claimClickClackSetupCode } = await import("./setup-claim-Cfv5ikVH.mjs");
+			const { claimClickClackSetupCode } = await import("./setup-claim-C-9Pvumz.mjs");
 			claim = await claimClickClackSetupCode({
 				claimUrl,
 				code: setup.code,
@@ -553,7 +530,7 @@ const clickClackSetupAdapter = {
 		});
 	},
 	afterAccountConfigWritten: async ({ cfg, accountId, runtime }) => {
-		const { verifyClickClackAccountAfterSetup } = await import("./setup-verify-POQZk8SG.mjs");
+		const { verifyClickClackAccountAfterSetup } = await import("./setup-verify-2ruJKFPj.mjs");
 		await verifyClickClackAccountAfterSetup({
 			cfg,
 			accountId,
@@ -735,7 +712,7 @@ const clickClackSetupWizard = {
 		})
 	}],
 	finalize: async ({ cfg, accountId, credentialValues, prompter }) => {
-		const { checkClickClackSetupConnection } = await import("./setup-verify-POQZk8SG.mjs");
+		const { checkClickClackSetupConnection } = await import("./setup-verify-2ruJKFPj.mjs");
 		const result = await checkClickClackSetupConnection({
 			cfg,
 			accountId,

package/dist/.setup/{setup-verify-POQZk8SG.mjs → setup-verify-2ruJKFPj.mjs}

@@ -1,5 +1,5 @@
-import { h as resolveClickClackAccount } from "./setup-surface-DcF_7-VV.mjs";
-import { a as createClickClackClient, r as resolveWorkspaceId } from "./resolve-DPtjHQHt.mjs";
+import { h as resolveClickClackAccount } from "./setup-surface-BJ5D55LV.mjs";
+import { a as createClickClackClient, r as resolveWorkspaceId } from "./resolve-Br3ylpSz.mjs";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/setup";

package/dist/api.js

@@ -1,4 +1,4 @@
-import { _ as resolveDefaultClickClackAccountId, d as DEFAULT_ACCOUNT_ID, h as resolveClickClackAccount, m as listEnabledClickClackAccounts, p as listClickClackAccountIds, s as clickClackConfigSchema } from "./.setup/setup-surface-DcF_7-VV.mjs";
-import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-DI3hKiSg.mjs";
-import { a as createClickClackClient } from "./.setup/resolve-DPtjHQHt.mjs";
+import { _ as resolveDefaultClickClackAccountId, d as DEFAULT_ACCOUNT_ID, h as resolveClickClackAccount, m as listEnabledClickClackAccounts, p as listClickClackAccountIds, s as clickClackConfigSchema } from "./.setup/setup-surface-BJ5D55LV.mjs";
+import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./.setup/channel-BFuhVeiX.mjs";
+import { a as createClickClackClient } from "./.setup/resolve-Br3ylpSz.mjs";
 export { DEFAULT_ACCOUNT_ID, buildClickClackTarget, clickClackConfigSchema, clickClackPlugin, createClickClackClient, getClickClackRuntime, listClickClackAccountIds, listEnabledClickClackAccounts, parseClickClackTarget, resolveClickClackAccount, resolveDefaultClickClackAccountId, setClickClackRuntime };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackPlugin } from "./.setup/channel-DI3hKiSg.mjs";
+import { t as clickClackPlugin } from "./.setup/channel-BFuhVeiX.mjs";
 export { clickClackPlugin };

package/dist/index.js

@@ -1,9 +1,6 @@
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-Dm_MQHNq.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-hAV5Muz-.mjs";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/clickclack/index.ts
-/**
-* Bundled channel entry metadata for the ClickClack plugin.
-*/
 var clickclack_default = defineBundledChannelEntry({
 	id: "clickclack",
 	name: "ClickClack",

package/dist/runtime-api.js

@@ -1,5 +1,5 @@
-import { h as resolveClickClackAccount } from "./.setup/setup-surface-DcF_7-VV.mjs";
-import { a as setClickClackRuntime, r as parseClickClackTarget } from "./.setup/channel-DI3hKiSg.mjs";
-import { a as createClickClackClient } from "./.setup/resolve-DPtjHQHt.mjs";
-import { t as registerClickClackDiscussions } from "./.setup/runtime-api-Dm_MQHNq.mjs";
+import { h as resolveClickClackAccount } from "./.setup/setup-surface-BJ5D55LV.mjs";
+import { a as setClickClackRuntime, r as parseClickClackTarget } from "./.setup/channel-BFuhVeiX.mjs";
+import { a as createClickClackClient } from "./.setup/resolve-Br3ylpSz.mjs";
+import { t as registerClickClackDiscussions } from "./.setup/runtime-api-hAV5Muz-.mjs";
 export { createClickClackClient, parseClickClackTarget, registerClickClackDiscussions, resolveClickClackAccount, setClickClackRuntime };

package/dist/setup-entry.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 var setup_entry_default = defineBundledChannelSetupEntry({
 	importMetaUrl: import.meta.url,
 	plugin: {
-		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-BXhjNJRg.mjs", import.meta.url).href),
+		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-DpKXmzV1.mjs", import.meta.url).href),
 		exportName: "clickClackSetupPlugin"
 	},
 	secrets: {

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackSetupPlugin } from "./.setup/setup-plugin-api-CqfAb-CU.mjs";
+import { t as clickClackSetupPlugin } from "./.setup/setup-plugin-api-Qi8u_lra.mjs";
 export { clickClackSetupPlugin };

package/node_modules/ws/lib/websocket.js

@@ -75,11 +75,24 @@ class WebSocket extends EventEmitter {
       this._redirects = 0;
 
       if (protocols === undefined) {
-        protocols = [];
+        if (!options || options.protocols === undefined) {
+          protocols = [];
+        } else if (Array.isArray(options.protocols)) {
+          protocols = options.protocols;
+        } else {
+          protocols = [options.protocols];
+        }
       } else if (!Array.isArray(protocols)) {
         if (typeof protocols === 'object' && protocols !== null) {
           options = protocols;
-          protocols = [];
+
+          if (options.protocols === undefined) {
+            protocols = [];
+          } else if (Array.isArray(options.protocols)) {
+            protocols = options.protocols;
+          } else {
+            protocols = [options.protocols];
+          }
         } else {
           protocols = [protocols];
         }
@@ -318,7 +331,6 @@ class WebSocket extends EventEmitter {
       return;
     }
 
-    this._readyState = WebSocket.CLOSING;
     this._sender.close(code, data, !this._isServer, (err) => {
       //
       // This error is handled by the `'error'` listener on the socket. We only
@@ -336,6 +348,7 @@ class WebSocket extends EventEmitter {
       }
     });
 
+    this._readyState = WebSocket.CLOSING;
     setCloseTimer(this);
   }
 
@@ -681,6 +694,7 @@ function initAsClient(websocket, address, protocols, options) {
     socketPath: undefined,
     hostname: undefined,
     protocol: undefined,
+    protocols: undefined,
     timeout: undefined,
     method: 'GET',
     host: undefined,

package/node_modules/ws/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ws",
-  "version": "8.21.3",
+  "version": "8.22.0",
   "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
   "keywords": [
     "HyBi",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/clickclack",
-  "version": "2026.10.1",
+  "version": "2026.10.5-beta.1",
   "description": "OpenClaw ClickClack channel plugin",
   "type": "module",
   "exports": {
@@ -9,11 +9,11 @@
     "./runtime-api.js": "./dist/runtime-api.js"
   },
   "dependencies": {
-    "ws": "8.21.3",
+    "ws": "8.22.0",
     "zod": "4.6.5"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.10.1"
+    "openclaw": ">=2026.10.5-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -139,10 +139,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.10.1"
+      "pluginApi": ">=2026.10.5-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.10.1",
+      "openclawVersion": "2026.10.5-beta.1",
       "bundledDist": false
     },
     "release": {

package/dist/.setup/setup-plugin-api-BXhjNJRg.mjs

@@ -1,2 +0,0 @@
-import { t as clickClackSetupPlugin } from "./setup-plugin-api-CqfAb-CU.mjs";
-export { clickClackSetupPlugin };