@openclaw/clickclack 2026.7.2-beta.3 → 2026.7.2-beta.5

package/README.md

@@ -10,6 +10,18 @@ openclaw plugins install @openclaw/clickclack
 
 ## Setup
 
+The recommended setup path uses the one-time command generated by ClickClack:
+
+```sh
+openclaw channels add clickclack --code 'https://clickclack.example.com/#XXXX-XXXX-XXXX'
+```
+
+Split-origin and path-mounted ClickClack deployments generate an exact
+`/api/bot-setup-codes/claim#CODE` endpoint. OpenClaw validates the versioned
+claim response and saves its canonical API base.
+
+For manual token setup:
+
 ```sh
 openclaw channels add clickclack \
   --base-url https://clickclack.example.com \
@@ -24,6 +36,31 @@ Run `openclaw onboard` for guided setup. The workspace value can be a
 For the default account only, `--use-env` reads `CLICKCLACK_BOT_TOKEN`; config
 storage is the normal setup path.
 
+### Public and private endpoints
+
+`baseUrl` is the public ClickClack URL used in links that people open. Set the
+optional `apiBaseUrl` when the gateway should call ClickClack through a
+different server-to-server endpoint:
+
+```json5
+{
+  channels: {
+    clickclack: {
+      baseUrl: "https://clack.openclaw.ai",
+      apiBaseUrl: "http://127.0.0.1:8484",
+      token: { source: "env", provider: "default", id: "CLICKCLACK_BOT_TOKEN" },
+      workspace: "default",
+    },
+  },
+}
+```
+
+This same-host pattern lets the public hostname stay fully protected by an
+authentication gateway such as Cloudflare Access while the local OpenClaw
+gateway talks directly to ClickClack. REST requests, setup verification, and
+the realtime WebSocket use `apiBaseUrl`; browser-facing discussion links keep
+using `baseUrl`. When `apiBaseUrl` is unset, it defaults to `baseUrl`.
+
 ## Command menus
 
 ClickClack command menus are enabled by default. At gateway startup, the
@@ -35,6 +72,94 @@ Set `commandMenu: false` on an account to disable menu sync. Sync failures do
 not prevent the gateway from starting, so older tokens and ClickClack servers
 continue to work without a menu.
 
+## Discussions
+
+ClickClack can create one managed channel for each OpenClaw session:
+
+The account token needs `channels:write`, which is included in `bot:admin` but
+not in the normal `bot:write` setup token. The ClickClack server must also
+support and return the managed-channel fields used by this integration.
+
+```json5
+{
+  channels: {
+    clickclack: {
+      baseUrl: "https://clickclack.example.com",
+      token: { source: "env", provider: "default", id: "CLICKCLACK_BOT_TOKEN" },
+      workspace: "default",
+      discussions: {
+        enabled: true,
+        workspace: "default",
+        controlUrlBase: "https://team.openclaw.ai",
+        section: "Sessions",
+      },
+    },
+  },
+}
+```
+
+Opening a session discussion creates a public, externally managed channel and
+stores its binding in the ClickClack plugin's SQLite state. Session archive,
+restore, label, category, and deletion changes are reflected in the channel;
+deletion archives the channel and never deletes its messages. `workspace`
+defaults to the account workspace, and `section` defaults to `Sessions`.
+`controlUrlBase` adds a link back to `/chat?session=<session-key>` in the
+OpenClaw Control UI.
+
+ClickClack-managed embed URLs explicitly advertise host-theme support. The
+Control UI uses that provider-owned capability to apply its full palette before
+the sidebar first paints and to stream live palette changes without rewriting
+opaque or signed discussion URLs from other providers.
+
+Enable discussions on exactly one ClickClack account. Multiple enabled
+discussion accounts are rejected because the session discussion provider does
+not have an account selector.
+
+Messages in the managed channel run in a stable side session under the same
+agent id as the attached main session. The plugin installs a scoped host grant
+for `sessions_history`, `session_status`, and `sessions_send` between that side
+session and its attached main session, so `tools.sessions.visibility` can stay
+at its safer default `tree`. A second host-side policy blocks session discovery
+and alternate targets; the side-agent prompt is not the authorization boundary.
+The agent still needs those three tools in its effective tool allowlist.
+
+The binding, managed ownership reference, and side-session identity include the
+concrete OpenClaw session id as well as the pinned server and channel. Resetting
+a reusable session key, replacing a binding, or retargeting it therefore revokes
+the old channel locally, archives it when the old credential remains usable, and
+starts a fresh channel and side transcript.
+Messages arriving through an archived, reset, disabled, or retargeted managed
+binding are dropped instead of falling back to the account's normal channel
+routing. Released bindings leave a durable revoked-channel marker so delayed
+realtime events remain fail-closed. Remote ownership is keyed by ClickClack
+server and channel id, so renaming the local account cannot turn a managed
+channel into an ordinary one.
+
+Managed-channel ownership references include a durable per-installation id, so
+two OpenClaw gateways using the same ClickClack workspace do not adopt each
+other's discussion channels. They also include the destination and a durable
+binding generation, so an account or workspace round trip cannot re-adopt a
+previous channel. Changing or removing `controlUrlBase` is reflected on the next
+lifecycle reconciliation pass.
+
+If a channel-create response is lost, the pending ownership reservation
+temporarily quarantines otherwise-unbound events in that workspace. The same
+coarse reconciler then adopts the created channel or clears/archives the
+ambiguous attempt; a reset cannot make the old channel fall through to ordinary
+routing.
+
+When a workspace move keeps the original workspace credential configured, the
+plugin archives the old channel before release. If the token is replaced with a
+workspace-scoped credential that cannot access the old workspace, OpenClaw
+releases the binding into the revoked-channel marker without trying the new token
+against the old channel; archive that leftover channel from ClickClack.
+
+The main session gets a read-only `discussion` tool that pulls the latest
+channel messages, including recent thread replies. The pull uses bounded
+history and thread-request budgets; its output says when older active threads
+may have been omitted. It never posts, archives, renames, or otherwise mutates
+the discussion.
+
 ## Docs
 
 See `docs/channels/clickclack.md` in the OpenClaw repository, or the published docs at `https://docs.openclaw.ai/channels/clickclack`.

package/dist/api.js

@@ -1,3 +1,3 @@
-import { a as createClickClackClient, d as DEFAULT_ACCOUNT_ID, f as listClickClackAccountIds, h as resolveDefaultClickClackAccountId, m as resolveClickClackAccount, p as listEnabledClickClackAccounts, s as clickClackConfigSchema } from "./setup-surface-CNjp76Xx.js";
-import { a as setClickClackRuntime, i as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./channel-CEYthZ9N.js";
+import { S as resolveDefaultClickClackAccountId, b as listEnabledClickClackAccounts, d as createClickClackClient, m as clickClackConfigSchema, v as DEFAULT_ACCOUNT_ID, x as resolveClickClackAccount, y as listClickClackAccountIds } from "./setup-surface-CD6MUC1g.js";
+import { D as setClickClackRuntime, E as getClickClackRuntime, n as buildClickClackTarget, r as parseClickClackTarget, t as clickClackPlugin } from "./channel-DfcFlLjC.js";
 export { DEFAULT_ACCOUNT_ID, buildClickClackTarget, clickClackConfigSchema, clickClackPlugin, createClickClackClient, getClickClackRuntime, listClickClackAccountIds, listEnabledClickClackAccounts, parseClickClackTarget, resolveClickClackAccount, resolveDefaultClickClackAccountId, setClickClackRuntime };

package/dist/{channel-CEYthZ9N.js → channel-DfcFlLjC.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-CNjp76Xx.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-CD6MUC1g.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";
@@ -10,9 +10,9 @@ 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 { FormatCapabilityProfile, 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
@@ -328,6 +328,353 @@ 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 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 Array.from(label).slice(0, 200).join("").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, 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
+	};
+}
+/** Public embed/open URLs for one bound discussion channel. */
+function discussionInfoForBinding(binding, account) {
+	const baseUrl = normalizedServerBaseUrl(account);
+	return {
+		state: "open",
+		embedUrl: `${baseUrl}/embed/channel/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}?openclawHostTheme=1`,
+		openUrl: `${baseUrl}/app/${encodeURIComponent(binding.workspaceRouteId)}/${encodeURIComponent(binding.channelRouteId)}`
+	};
+}
+//#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.
@@ -378,6 +725,23 @@ function looksLikeClickClackTarget(raw) {
 * and direct messages.
 */
 const CLICKCLACK_MAX_UPLOAD_BYTES = 64 * 1024 * 1024;
+const CLICKCLACK_FORMAT_PROFILE = FormatCapabilityProfile.define({
+	mechanism: "markdown",
+	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);
@@ -453,7 +817,7 @@ function createOutboundContext(params) {
 	return {
 		account,
 		client: createClickClackClient({
-			baseUrl: account.baseUrl,
+			baseUrl: account.apiEndpoint,
 			token: account.token,
 			correlationId: params.correlationId
 		})
@@ -464,7 +828,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);
@@ -524,7 +888,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,
@@ -753,13 +1117,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,
@@ -774,7 +1154,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
 		}),
@@ -841,7 +1221,10 @@ async function handleClickClackInbound(params) {
 				wasMentioned: !isDirect
 			}
 		},
-		extra: { GroupChannel: message.channel_id }
+		extra: {
+			GroupChannel: message.channel_id,
+			...discussionRoute ? { GroupSystemPrompt: discussionRoute.systemPrompt } : {}
+		}
 	});
 	const runId = resolveClickClackAgentRunId(message.id);
 	const activityReplyOptions = activity ? {
@@ -960,7 +1343,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,
@@ -1006,7 +1389,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);
@@ -1228,6 +1611,7 @@ const clickClackPlugin = createChatChannelPlugin({
 		configSchema: clickClackConfigSchema,
 		config: clickClackConfigAdapter,
 		setup: clickClackSetupAdapter,
+		setupContract: clickClackSetupContract,
 		setupWizard: clickClackSetupWizard,
 		secrets: {
 			secretTargetRegistryEntries,
@@ -1333,4 +1717,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { setClickClackRuntime as a, getClickClackRuntime as i, buildClickClackTarget as n, parseClickClackTarget as r, clickClackPlugin as t };
+export { listPendingDiscussionOpens as C, setClickClackRuntime as D, getClickClackRuntime as E, clearDiscussionBindingGeneration as S, reserveDiscussionBindingGeneration as T, fallbackDiscussionLabel as _, isClickClackDiscussionChannelRevoked as a, slugifyDiscussionLabel as b, discussionAccounts as c, resolveDiscussionBindingAccount as d, bindingMatchesActiveSessionIncarnation as f, discussionExternalRef as g, discussionCredentialFingerprint as h, clearClickClackDiscussionChannelRevoked as i, discussionInfoForBinding as l, getClickClackDiscussionBindingStore as m, buildClickClackTarget as n, markClickClackDiscussionChannelIdentityRevoked as o, bindingMatchesSessionIncarnation as p, parseClickClackTarget as r, markClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, normalizedServerBaseUrl as u, isDiscussionSessionKey as v, recordPendingDiscussionOpen as w, truncateDiscussionDisplayTitle as x, resolveDiscussionLabel as y };

package/dist/channel-plugin-api.js

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