@openclaw/clickclack 2026.7.2-beta.5 → 2026.7.33

package/dist/channel-DfcFlLjC.js

@@ -1,1720 +0,0 @@
-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";
-import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
-import { createChannelInboundEnvelopeBuilder } from "openclaw/plugin-sdk/channel-inbound";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-import { createHash, randomUUID } from "node:crypto";
-import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
-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
-* bundled plugin.
-*/
-const { setRuntime: setClickClackRuntime, getRuntime: getClickClackRuntime } = createPluginRuntimeStore({
-	pluginId: "clickclack",
-	errorMessage: "ClickClack runtime not initialized"
-});
-//#endregion
-//#region extensions/clickclack/src/access.ts
-/**
-* Maps ClickClack senders and conversations onto the shared channel ingress
-* allowlist/command authorization contract.
-*/
-const CHANNEL_ID$2 = "clickclack";
-function normalizeClickClackUserId(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	const withoutProvider = trimmed.replace(/^(clickclack|cc):/i, "").trim();
-	return withoutProvider.match(/^dm:(.+)$/i)?.[1]?.trim() || withoutProvider || null;
-}
-const clickClackIngressIdentity = {
-	key: "user-id",
-	normalizeEntry: normalizeClickClackUserId,
-	normalizeSubject: normalizeClickClackUserId,
-	isWildcardEntry: (entry) => normalizeClickClackUserId(entry) === "*",
-	entryIdPrefix: "clickclack-user"
-};
-/**
-* Resolves whether a ClickClack message should enter the agent pipeline and
-* whether its command-style body may run tools.
-*/
-async function resolveClickClackInboundAccess(params) {
-	const runtime = getClickClackRuntime();
-	const isDirect = Boolean(params.message.direct_conversation_id);
-	const cfg = params.config;
-	const shouldCheckCommand = runtime.channel.commands.shouldComputeCommandAuthorized(params.message.body, cfg);
-	const resolved = await resolveStableChannelMessageIngress({
-		channelId: CHANNEL_ID$2,
-		accountId: params.account.accountId,
-		identity: clickClackIngressIdentity,
-		cfg,
-		subject: { stableId: params.message.author_id },
-		conversation: {
-			kind: isDirect ? "direct" : "group",
-			id: isDirect ? params.message.direct_conversation_id ?? params.message.author_id : params.message.channel_id ?? params.message.thread_root_id
-		},
-		allowFrom: params.account.allowFrom,
-		dmPolicy: "allowlist",
-		groupPolicy: "allowlist",
-		command: shouldCheckCommand ? {
-			cfg,
-			modeWhenAccessGroupsOff: "configured"
-		} : false
-	});
-	return {
-		shouldDispatch: resolved.ingress.admission === "dispatch",
-		commandAuthorized: resolved.commandAccess.requested ? resolved.commandAccess.authorized : resolved.senderAccess.allowed
-	};
-}
-//#endregion
-//#region extensions/clickclack/src/command-menu.ts
-const CLICKCLACK_COMMAND_PATTERN = /^[a-z0-9_-]{1,32}$/u;
-const CLICKCLACK_MAX_COMMANDS = 100;
-const CLICKCLACK_MAX_DESCRIPTION_LENGTH = 100;
-const CLICKCLACK_MAX_ARGS_HINT_LENGTH = 100;
-function truncateCodePoints(value, maxLength) {
-	return Array.from(value).slice(0, maxLength).join("");
-}
-function commandArgsHint(spec) {
-	if (spec.args?.length) return truncateCodePoints(spec.args.map((arg) => arg.required ? `<${arg.name}>` : `[${arg.name}]`).join(" "), CLICKCLACK_MAX_ARGS_HINT_LENGTH);
-	return spec.acceptsArgs ? "[args]" : "";
-}
-function errorStatus(error) {
-	if (!error || typeof error !== "object" || !("status" in error)) return;
-	const status = error.status;
-	return typeof status === "number" ? status : void 0;
-}
-function mapNativeCommandSpecsToClickClackMenu(specs, log) {
-	const commands = [];
-	const seen = /* @__PURE__ */ new Set();
-	const invalidNames = /* @__PURE__ */ new Set();
-	for (const spec of specs) {
-		if (spec.isAlias) continue;
-		const command = spec.name.trim().toLowerCase();
-		if (!CLICKCLACK_COMMAND_PATTERN.test(command)) {
-			invalidNames.add(spec.name.trim() || "<empty>");
-			continue;
-		}
-		if (seen.has(command)) continue;
-		seen.add(command);
-		const description = spec.description.trim() || command;
-		commands.push({
-			command,
-			description: truncateCodePoints(description, CLICKCLACK_MAX_DESCRIPTION_LENGTH),
-			args_hint: commandArgsHint(spec)
-		});
-	}
-	if (invalidNames.size > 0) log?.warn?.(`ClickClack command menu skipped invalid native command names: ${[...invalidNames].map((name) => JSON.stringify(name)).join(", ")}`);
-	return commands.slice(0, CLICKCLACK_MAX_COMMANDS);
-}
-async function syncClickClackCommandMenu(params) {
-	try {
-		const commands = mapNativeCommandSpecsToClickClackMenu(listNativeCommandSpecsForConfig(params.cfg, { provider: "clickclack" }), params.log);
-		await params.client.setBotCommands(commands);
-	} catch (error) {
-		const status = errorStatus(error);
-		if (status === 403) {
-			params.log?.warn?.("ClickClack command menu sync skipped: bot token lacks commands:write");
-			return;
-		}
-		if (status === 404) {
-			params.log?.debug?.("ClickClack command menu sync skipped: server does not support /api/bots/self/commands");
-			return;
-		}
-		params.log?.warn?.(`ClickClack command menu sync failed: ${formatErrorMessage(error)}`);
-	}
-}
-//#endregion
-//#region extensions/clickclack/src/activity.ts
-/**
-* Publishes agent activity (streamed commentary + tool progress) into
-* ClickClack as durable `agent_commentary` / `agent_tool` message rows,
-* coalesced so one logical step becomes one row instead of a row per frame.
-*
-* Ported from the clickglass agent-bridge sidecar, adapted from gateway
-* websocket frames to the in-process `replyOptions.onItemEvent` seam:
-*
-* - Commentary/reasoning arrives as cumulative text snapshots per item id.
-*   Each segment becomes one durable row: POSTed when the segment starts
-*   streaming and PATCHed (debounced) as the snapshot grows, so prose
-*   interleaves chronologically with tool rows.
-* - Tool/step items can emit several frames (start/update/complete) for the
-*   same call, sometimes with lane-prefixed ids (`tool:X`, `command:X`).
-*   Normalize the prefix away to one key per call, POST one row on the first
-*   frame, and PATCH it when a later frame carries a strictly longer body.
-*/
-/** Debounce window for PATCHing streaming commentary snapshots. */
-const CLICKCLACK_COMMENTARY_FLUSH_MS = 700;
-/** Item kinds rendered as agent_tool rows; everything else is commentary. */
-const TOOL_ITEM_KINDS = /* @__PURE__ */ new Set([
-	"tool",
-	"command",
-	"command_output",
-	"patch",
-	"search",
-	"api"
-]);
-/** Item kinds that never become durable rows (ephemeral or plumbing lanes). */
-const SKIPPED_ITEM_KINDS = /* @__PURE__ */ new Set(["lifecycle"]);
-/** Item kinds emitted as cumulative commentary snapshots. */
-const STREAMING_COMMENTARY_ITEM_KINDS = /* @__PURE__ */ new Set([
-	"preamble",
-	"commentary",
-	"analysis",
-	"thinking",
-	"reasoning"
-]);
-/** Provider-specific reasoning lanes normalized into one ClickClack label. */
-const THINKING_ITEM_KINDS = /* @__PURE__ */ new Set([
-	"analysis",
-	"thinking",
-	"reasoning"
-]);
-function normalizedItemKind(payload) {
-	return payload.kind?.trim().toLowerCase() ?? "";
-}
-function commentaryBody(payload) {
-	const text = payload.progressText?.trim() || payload.summary?.trim() || payload.meta?.trim() || "";
-	if (!text) return "";
-	const kind = normalizedItemKind(payload);
-	if (THINKING_ITEM_KINDS.has(kind)) return `**Thinking**\n\n${text}`;
-	return text;
-}
-function activityBody(payload) {
-	const line = buildChannelProgressDraftLine({
-		event: "item",
-		itemId: payload.itemId,
-		toolCallId: payload.toolCallId,
-		itemKind: payload.kind,
-		title: payload.title,
-		name: payload.name,
-		phase: payload.phase,
-		status: payload.status,
-		summary: payload.summary,
-		progressText: payload.progressText,
-		meta: payload.meta
-	})?.text?.trim();
-	if (line) return line;
-	const head = payload.name?.trim() || payload.title?.trim();
-	const text = payload.progressText?.trim() || payload.summary?.trim();
-	if (head && text) return `**${head}**\n\n${text}`;
-	if (text) return text;
-	if (head) return head;
-	return payload.status?.trim() || payload.kind?.trim() || "";
-}
-/**
-* Creates a per-turn activity publisher. Publishing is best-effort: transport
-* failures are reported through `onError` and never interrupt the reply turn.
-*/
-function createClickClackActivityPublisher(params) {
-	const flushMs = params.flushMs ?? CLICKCLACK_COMMENTARY_FLUSH_MS;
-	const commentaryByItem = /* @__PURE__ */ new Map();
-	const toolRows = /* @__PURE__ */ new Map();
-	let provenance;
-	let chain = Promise.resolve();
-	const enqueue = (work) => {
-		chain = chain.then(work).catch((error) => {
-			params.onError?.(error);
-		});
-		return chain;
-	};
-	const postRow = (kind, body) => params.client.createActivityMessage({
-		channelId: params.target.channelId,
-		conversationId: params.target.conversationId,
-		body,
-		kind,
-		turnId: params.turnId,
-		provenance
-	});
-	const flushCommentary = (segmentKey) => {
-		const segment = commentaryByItem.get(segmentKey);
-		if (!segment) return Promise.resolve();
-		if (segment.timer) {
-			clearTimeout(segment.timer);
-			segment.timer = void 0;
-		}
-		if (!segment.dirty || !segment.body.trim()) return Promise.resolve();
-		segment.dirty = false;
-		const body = segment.body;
-		return enqueue(async () => {
-			if (segment.messageId) {
-				await params.client.updateMessageBody(segment.messageId, body);
-				return;
-			}
-			const posted = await postRow("agent_commentary", body);
-			segment.messageId = posted.id;
-		});
-	};
-	const flushAllCommentary = () => {
-		const flushes = [...commentaryByItem.keys()].map((key) => flushCommentary(key));
-		return Promise.all(flushes).then(() => void 0);
-	};
-	const handleCommentary = (payload) => {
-		const body = commentaryBody(payload);
-		if (!body.trim()) return;
-		const key = payload.itemId?.trim() || "turn";
-		let segment = commentaryByItem.get(key);
-		if (!segment) {
-			segment = {
-				body: "",
-				dirty: false
-			};
-			commentaryByItem.set(key, segment);
-		}
-		if (body.length < segment.body.length || body === segment.body) return;
-		segment.body = body;
-		segment.dirty = true;
-		if (!segment.timer) segment.timer = setTimeout(() => {
-			segment.timer = void 0;
-			flushCommentary(key);
-		}, flushMs);
-	};
-	const toolRowKey = (payload) => {
-		const toolCallId = payload.toolCallId?.trim();
-		if (toolCallId) return toolCallId;
-		return (payload.itemId?.trim() ?? "").replace(/^(tool|command):/, "");
-	};
-	const handleDiscreteItem = (payload) => {
-		const body = activityBody(payload);
-		if (!body) return;
-		const kind = TOOL_ITEM_KINDS.has(payload.kind?.trim().toLowerCase() ?? "") ? "agent_tool" : "agent_commentary";
-		flushAllCommentary();
-		const key = `${kind}:${toolRowKey(payload)}`;
-		const existing = toolRows.get(key);
-		if (!existing || !toolRowKey(payload)) {
-			const row = { body };
-			if (toolRowKey(payload)) toolRows.set(key, row);
-			enqueue(async () => {
-				const posted = await postRow(kind, row.body);
-				row.messageId = posted.id;
-				row.sentBody = row.body;
-			});
-			return;
-		}
-		if (body.length <= existing.body.length) return;
-		existing.body = body;
-		enqueue(async () => {
-			if (existing.messageId && existing.body !== existing.sentBody) {
-				await params.client.updateMessageBody(existing.messageId, existing.body);
-				existing.sentBody = existing.body;
-			}
-		});
-	};
-	return {
-		onItemEvent: (payload) => {
-			const kind = normalizedItemKind(payload);
-			if (STREAMING_COMMENTARY_ITEM_KINDS.has(kind)) {
-				handleCommentary(payload);
-				return;
-			}
-			if (SKIPPED_ITEM_KINDS.has(kind)) return;
-			handleDiscreteItem(payload);
-		},
-		setProvenance: (next) => {
-			provenance = next;
-		},
-		finalize: async () => {
-			await flushAllCommentary();
-			await chain;
-		}
-	};
-}
-//#endregion
-//#region extensions/clickclack/src/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.
-*/
-function parseClickClackTarget(raw) {
-	const value = raw.trim();
-	if (!value) throw new Error("ClickClack target is required");
-	const [prefix, ...rest] = value.split(":");
-	const body = rest.join(":").trim();
-	if (prefix === "channel" && body) return {
-		chatType: "group",
-		kind: "channel",
-		id: body
-	};
-	if (prefix === "thread" && body) return {
-		chatType: "group",
-		kind: "thread",
-		id: body
-	};
-	if (prefix === "dm" && body) return {
-		chatType: "direct",
-		kind: "dm",
-		id: body
-	};
-	if (!body) return {
-		chatType: "group",
-		kind: "channel",
-		id: value
-	};
-	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;
-}
-//#endregion
-//#region extensions/clickclack/src/outbound.ts
-/**
-* Outbound ClickClack delivery helpers for channel messages, thread replies,
-* 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);
-	const replyToId = params.replyToId == null ? "" : String(params.replyToId);
-	if (explicitThreadId || parsed.kind === "thread") {
-		const rootId = explicitThreadId || parsed.id;
-		await params.onPlatformSendDispatch?.();
-		return await params.client.createThreadReply(rootId, params.text, {
-			provenance: params.provenance,
-			nonce: params.nonce
-		});
-	}
-	if (parsed.kind === "dm") {
-		await params.onPlatformSendDispatch?.();
-		const dm = await params.client.createDirectConversation(params.workspaceId, [parsed.id]);
-		return await params.client.createDirectMessage(dm.id, params.text, {
-			quotedMessageId: replyToId || void 0,
-			nonce: params.nonce
-		});
-	}
-	const channelId = await resolveChannelId(params.client, params.workspaceId, parsed.id);
-	await params.onPlatformSendDispatch?.();
-	return await params.client.createChannelMessage(channelId, params.text, {
-		provenance: params.provenance,
-		quotedMessageId: replyToId || void 0,
-		nonce: params.nonce
-	});
-}
-function durableDeliveryDigest(params) {
-	if (!params.deliveryQueueId) return;
-	if (!Number.isSafeInteger(params.deliveryPartIndex) || (params.deliveryPartIndex ?? -1) < 0) throw new Error("ClickClack durable delivery requires a stable delivery part index");
-	return createHash("sha256").update(`${params.deliveryQueueId}\n${params.deliveryPartIndex}`).digest("hex");
-}
-function mediaDeliveryNonces(params) {
-	const digest = durableDeliveryDigest(params);
-	if (!digest) return {};
-	return {
-		message: `openclaw-media:${digest}`,
-		upload: `openclaw-upload:${digest}`
-	};
-}
-function textDeliveryNonce(params) {
-	const digest = durableDeliveryDigest(params);
-	return digest ? `openclaw-text:${digest}` : void 0;
-}
-function createDispatchOnce(onPlatformSendDispatch) {
-	let dispatched = false;
-	return async () => {
-		if (dispatched) return;
-		await onPlatformSendDispatch?.();
-		dispatched = true;
-	};
-}
-async function attachUploadRetrySafe(params) {
-	try {
-		await params.client.attachUpload(params.messageId, params.uploadId);
-	} catch (firstError) {
-		try {
-			if ((await params.client.message(params.messageId)).attachments?.some((attachment) => attachment.id === params.uploadId)) return;
-		} catch {}
-		try {
-			await params.client.attachUpload(params.messageId, params.uploadId);
-		} catch {
-			throw firstError;
-		}
-	}
-}
-function createOutboundContext(params) {
-	const account = resolveClickClackAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	return {
-		account,
-		client: createClickClackClient({
-			baseUrl: account.apiEndpoint,
-			token: account.token,
-			correlationId: params.correlationId
-		})
-	};
-}
-/**
-* Sends visible text to a normalized ClickClack target and returns the created
-* message id, or undefined when sanitization removes all content.
-*/
-async function sendClickClackText(params) {
-	const text = renderClickClackMarkdown(sanitizeAssistantVisibleText(params.text));
-	if (!text) return;
-	const { account, client } = createOutboundContext(params);
-	const workspaceId = await resolveWorkspaceId(client, account.workspace);
-	const dispatch = createDispatchOnce(params.onPlatformSendDispatch);
-	return (await createTargetMessage({
-		client,
-		workspaceId,
-		to: params.to,
-		text,
-		threadId: params.threadId,
-		replyToId: params.replyToId,
-		provenance: params.provenance,
-		nonce: textDeliveryNonce({
-			deliveryQueueId: params.deliveryQueueId,
-			deliveryPartIndex: params.deliveryPartIndex
-		}),
-		onPlatformSendDispatch: dispatch
-	})).id;
-}
-/** Resolves, uploads, sends, then attaches one file to a ClickClack message. */
-async function sendClickClackMedia(params) {
-	const nonces = mediaDeliveryNonces({
-		deliveryQueueId: params.deliveryQueueId,
-		deliveryPartIndex: params.deliveryPartIndex
-	});
-	const preloadedMedia = nonces.upload ? void 0 : await loadOutboundMediaFromUrl(params.mediaUrl, {
-		maxBytes: CLICKCLACK_MAX_UPLOAD_BYTES,
-		mediaAccess: params.mediaAccess,
-		mediaLocalRoots: params.mediaLocalRoots,
-		mediaReadFile: params.mediaReadFile
-	});
-	const { account, client } = createOutboundContext(params);
-	const workspaceId = await resolveWorkspaceId(client, account.workspace);
-	const persistedUpload = nonces.upload ? await client.findUploadByNonce({
-		workspaceId,
-		nonce: nonces.upload
-	}) : void 0;
-	const dispatch = createDispatchOnce(params.onPlatformSendDispatch);
-	let upload = persistedUpload;
-	let mediaFilename = preloadedMedia?.fileName?.trim();
-	if (!upload) {
-		const media = preloadedMedia ?? await loadOutboundMediaFromUrl(params.mediaUrl, {
-			maxBytes: CLICKCLACK_MAX_UPLOAD_BYTES,
-			mediaAccess: params.mediaAccess,
-			mediaLocalRoots: params.mediaLocalRoots,
-			mediaReadFile: params.mediaReadFile
-		});
-		const filename = media.fileName?.trim() || "attachment";
-		mediaFilename = filename;
-		const contentType = media.contentType?.trim() || "application/octet-stream";
-		await dispatch();
-		upload = await client.createUpload({
-			workspaceId,
-			buffer: media.buffer,
-			filename,
-			contentType,
-			...nonces.upload ? { nonce: nonces.upload } : {}
-		});
-	}
-	const text = renderClickClackMarkdown(sanitizeAssistantVisibleText(params.text)) || mediaFilename || upload.filename || "attachment";
-	const message = await createTargetMessage({
-		client,
-		workspaceId,
-		to: params.to,
-		text,
-		threadId: params.threadId,
-		replyToId: params.replyToId,
-		nonce: nonces.message,
-		onPlatformSendDispatch: dispatch
-	});
-	await attachUploadRetrySafe({
-		client,
-		messageId: message.id,
-		uploadId: upload.id
-	});
-	return message.id;
-}
-function collectReconciliationMediaUrls(ctx) {
-	const planned = ctx.renderedBatchPlan?.items[0]?.mediaUrls;
-	if (planned?.length) return planned.map((url) => url.trim()).filter(Boolean);
-	const payload = ctx.payloads[0];
-	return [payload?.mediaUrl, ...payload?.mediaUrls ?? []].map((url) => url?.trim()).filter((url) => Boolean(url));
-}
-/**
-* Completes an unknown durable send through ClickClack's message/upload nonces.
-* Media recovery never rereads the original source after restart.
-*/
-async function reconcileClickClackUnknownSend(ctx) {
-	if (ctx.payloads.length !== 1 || (ctx.renderedBatchPlan?.items.length ?? 1) !== 1) return {
-		status: "unresolved",
-		error: "ClickClack reconciliation requires exactly one payload"
-	};
-	const mediaUrls = collectReconciliationMediaUrls(ctx);
-	const { account, client } = createOutboundContext({
-		cfg: ctx.cfg,
-		accountId: ctx.accountId
-	});
-	const workspaceId = await resolveWorkspaceId(client, account.workspace);
-	const effectiveReplyToId = ctx.effectiveReplyToId !== void 0 ? ctx.effectiveReplyToId : ctx.replyToMode === "off" ? void 0 : ctx.replyToId;
-	const payload = ctx.payloads[0];
-	const caption = ctx.renderedBatchPlan?.items[0]?.text ?? payload?.text ?? "";
-	if (mediaUrls.length === 0) {
-		const nonce = textDeliveryNonce({
-			deliveryQueueId: ctx.queueId,
-			deliveryPartIndex: 0
-		});
-		if (!nonce || !sanitizeAssistantVisibleText(caption)) return { status: "not_sent" };
-		const message = await client.findMessageByNonce({
-			workspaceId,
-			nonce
-		});
-		if (!message) return { status: "not_sent" };
-		const receipt = createMessageReceiptFromOutboundResults({
-			results: [{
-				channel: "clickclack",
-				messageId: message.id
-			}],
-			threadId: ctx.threadId == null ? void 0 : String(ctx.threadId),
-			replyToId: effectiveReplyToId ?? void 0,
-			kind: "text"
-		});
-		return {
-			status: "sent",
-			messageId: message.id,
-			receipt
-		};
-	}
-	const parts = await Promise.all(mediaUrls.map(async (_mediaUrl, index) => {
-		const nonces = mediaDeliveryNonces({
-			deliveryQueueId: ctx.queueId,
-			deliveryPartIndex: index
-		});
-		if (!nonces.upload || !nonces.message) throw new Error("ClickClack durable media nonces were not derived");
-		const [upload, message] = await Promise.all([client.findUploadByNonce({
-			workspaceId,
-			nonce: nonces.upload
-		}), client.findMessageByNonce({
-			workspaceId,
-			nonce: nonces.message
-		})]);
-		return {
-			upload,
-			message
-		};
-	}));
-	for (const part of parts) {
-		if (part.message && !part.upload) return {
-			status: "unresolved",
-			error: `ClickClack message ${part.message.id} exists without its nonce-keyed upload`,
-			retryable: false
-		};
-		if (!part.message) return { status: "not_sent" };
-	}
-	const messageIds = [];
-	for (const part of parts) {
-		const message = part.message;
-		const upload = part.upload;
-		if (!message || !upload) throw new Error("ClickClack reconciliation state changed unexpectedly");
-		if (!message.attachments?.some((attachment) => attachment.id === upload.id)) await attachUploadRetrySafe({
-			client,
-			messageId: message.id,
-			uploadId: upload.id
-		});
-		messageIds.push(message.id);
-	}
-	const receipt = createMessageReceiptFromOutboundResults({
-		results: messageIds.map((messageId) => ({
-			channel: "clickclack",
-			messageId
-		})),
-		threadId: ctx.threadId == null ? void 0 : String(ctx.threadId),
-		replyToId: effectiveReplyToId ?? void 0,
-		kind: "media"
-	});
-	const messageId = messageIds.at(-1);
-	return {
-		status: "sent",
-		...messageId ? { messageId } : {},
-		receipt
-	};
-}
-//#endregion
-//#region extensions/clickclack/src/inbound.ts
-const CHANNEL_ID$1 = "clickclack";
-const CLICKCLACK_MESSAGE_ID_PATTERN = /^msg_[0-9a-hjkmnp-tv-z]{26}$/u;
-function hasClickClackReplyMedia(payload) {
-	return Boolean(payload.mediaUrl?.trim() || payload.mediaUrls?.some((mediaUrl) => typeof mediaUrl === "string" && mediaUrl.trim()));
-}
-function resolveClickClackAgentRunId(messageId) {
-	return CLICKCLACK_MESSAGE_ID_PATTERN.test(messageId) ? `${CHANNEL_ID$1}:${messageId}` : void 0;
-}
-function resolveAccountAgentRoute(params) {
-	const runtime = getClickClackRuntime();
-	const route = runtime.channel.routing.resolveAgentRoute({
-		cfg: params.cfg,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		peer: {
-			kind: params.isDirect ? "direct" : "channel",
-			id: params.target
-		}
-	});
-	const agentId = normalizeAgentId(params.account.agentId ?? route.agentId);
-	if (agentId === route.agentId) return route;
-	const peer = {
-		kind: params.isDirect ? "direct" : "channel",
-		id: params.target
-	};
-	const dmScope = params.cfg.session?.dmScope ?? "main";
-	const sessionKey = runtime.channel.routing.buildAgentSessionKey({
-		agentId,
-		mainKey: params.cfg.session?.mainKey,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		peer,
-		dmScope,
-		identityLinks: params.cfg.session?.identityLinks
-	});
-	const mainSessionKey = runtime.channel.routing.buildAgentSessionKey({
-		agentId,
-		mainKey: params.cfg.session?.mainKey,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		dmScope: "main"
-	});
-	return {
-		...route,
-		agentId,
-		dmScope,
-		sessionKey,
-		mainSessionKey,
-		lastRoutePolicy: sessionKey === mainSessionKey ? "main" : "session"
-	};
-}
-async function dispatchModelReply(params) {
-	const runtime = getClickClackRuntime();
-	const text = (await runtime.llm.complete({
-		agentId: params.route.agentId,
-		model: params.account.model,
-		purpose: "clickclack bot reply",
-		systemPrompt: params.account.systemPrompt,
-		messages: [{
-			role: "user",
-			content: params.message.body
-		}]
-	})).text.trim();
-	if (!text) {
-		runtime.logging.getChildLogger({
-			plugin: "clickclack",
-			feature: "model-reply"
-		}).warn(`[${params.account.accountId}] ClickClack model reply produced no sendable text`);
-		return;
-	}
-	await sendClickClackText({
-		cfg: params.cfg,
-		accountId: params.account.accountId,
-		to: params.target,
-		text,
-		threadId: params.message.parent_message_id ? params.message.thread_root_id : void 0,
-		replyToId: params.message.id,
-		correlationId: params.correlationId
-	});
-}
-/**
-* Dispatches one already-fetched ClickClack message through the configured
-* reply mode for its account.
-*/
-async function handleClickClackInbound(params) {
-	const runtime = getClickClackRuntime();
-	const message = params.message;
-	const access = params.access ?? await resolveClickClackInboundAccess({
-		account: params.account,
-		config: params.config,
-		message
-	});
-	if (!access.shouldDispatch) return;
-	const conversationId = message.channel_id || message.direct_conversation_id;
-	if (!conversationId) return;
-	const isDirect = Boolean(message.direct_conversation_id);
-	const target = buildClickClackTarget(isDirect ? {
-		chatType: "direct",
-		kind: "dm",
-		id: message.author_id
-	} : {
-		chatType: "group",
-		kind: "channel",
-		id: message.channel_id ?? ""
-	});
-	const accountRoute = resolveAccountAgentRoute({
-		cfg: params.config,
-		account: params.account,
-		target,
-		isDirect
-	});
-	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,
-			message,
-			route,
-			target,
-			correlationId: params.correlationId
-		});
-		return;
-	}
-	let turnProvenance;
-	let activity;
-	if (params.account.agentActivity && (message.channel_id || message.direct_conversation_id)) activity = createClickClackActivityPublisher({
-		client: createClickClackClient({
-			baseUrl: params.account.apiEndpoint,
-			token: params.account.token,
-			correlationId: params.correlationId
-		}),
-		target: message.channel_id ? { channelId: message.channel_id } : { conversationId: message.direct_conversation_id },
-		turnId: message.id,
-		onError: (error) => {
-			runtime.logging.getChildLogger({
-				plugin: "clickclack",
-				feature: "agent-activity"
-			}).warn(`clickclack activity publish failed: ${String(error)}`);
-		}
-	});
-	const senderName = message.author?.display_name || message.author_id;
-	const body = createChannelInboundEnvelopeBuilder({
-		cfg: params.config,
-		route
-	})({
-		channel: "ClickClack",
-		from: senderName,
-		timestamp: new Date(message.created_at),
-		body: message.body
-	});
-	const ctxPayload = runtime.channel.inbound.buildContext({
-		channel: CHANNEL_ID$1,
-		accountId: route.accountId ?? params.account.accountId,
-		messageId: message.id,
-		messageIdFull: message.id,
-		timestamp: new Date(message.created_at).getTime(),
-		from: target,
-		sender: {
-			id: message.author_id,
-			name: senderName
-		},
-		conversation: {
-			kind: isDirect ? "direct" : "group",
-			id: conversationId,
-			label: isDirect ? senderName : message.channel_id,
-			threadId: message.parent_message_id ? message.thread_root_id : void 0,
-			nativeChannelId: conversationId
-		},
-		route: {
-			agentId: route.agentId,
-			dmScope: route.dmScope,
-			accountId: route.accountId,
-			routeSessionKey: route.sessionKey
-		},
-		reply: {
-			to: target,
-			originatingTo: target,
-			replyToId: message.id,
-			messageThreadId: message.parent_message_id ? message.thread_root_id : void 0,
-			threadParentId: message.parent_message_id ? message.thread_root_id : void 0
-		},
-		message: {
-			body,
-			bodyForAgent: message.body,
-			rawBody: message.body,
-			commandBody: message.body
-		},
-		access: {
-			commands: { authorized: access.commandAuthorized },
-			mentions: {
-				canDetectMention: !isDirect,
-				wasMentioned: !isDirect
-			}
-		},
-		extra: {
-			GroupChannel: message.channel_id,
-			...discussionRoute ? { GroupSystemPrompt: discussionRoute.systemPrompt } : {}
-		}
-	});
-	const runId = resolveClickClackAgentRunId(message.id);
-	const activityReplyOptions = activity ? {
-		onModelSelected: (ctx) => {
-			turnProvenance = {
-				model: ctx.provider && ctx.model ? `${ctx.provider}/${ctx.model}` : ctx.model,
-				thinking: ctx.thinkLevel
-			};
-			activity?.setProvenance(turnProvenance);
-		},
-		onItemEvent: activity.onItemEvent,
-		commentaryProgressEnabled: true,
-		suppressDefaultToolProgressMessages: true,
-		allowProgressCallbacksWhenSourceDeliverySuppressed: true
-	} : void 0;
-	const dispatchPromise = runtime.channel.inbound.dispatch({
-		cfg: params.config,
-		channel: CHANNEL_ID$1,
-		accountId: params.account.accountId,
-		route: {
-			agentId: route.agentId,
-			dmScope: route.dmScope,
-			sessionKey: route.sessionKey
-		},
-		ctxPayload,
-		toolsAllow: params.account.toolsAllow,
-		replyOptions: runId || activityReplyOptions ? {
-			...runId ? { runId } : {},
-			...activityReplyOptions
-		} : void 0,
-		delivery: {
-			deliver: async (payload) => {
-				if (hasClickClackReplyMedia(payload)) throw new Error("ClickClack media reply requires durable delivery");
-				const text = payload && typeof payload === "object" && "text" in payload ? payload.text ?? "" : "";
-				if (!text.trim()) return;
-				await sendClickClackText({
-					cfg: params.config,
-					accountId: params.account.accountId,
-					to: target,
-					text,
-					threadId: message.parent_message_id ? message.thread_root_id : void 0,
-					replyToId: message.id,
-					provenance: turnProvenance,
-					correlationId: params.correlationId
-				});
-			},
-			durable: (payload) => {
-				if (!hasClickClackReplyMedia(payload)) return false;
-				const threadId = message.parent_message_id ? message.thread_root_id : void 0;
-				return {
-					to: target,
-					threadId,
-					replyToId: message.id,
-					requiredCapabilities: deriveDurableFinalDeliveryRequirements({
-						payload,
-						threadId,
-						replyToId: message.id,
-						reconcileUnknownSend: true
-					})
-				};
-			},
-			onError: (error) => {
-				throw error instanceof Error ? error : /* @__PURE__ */ new Error(`clickclack dispatch failed: ${String(error)}`);
-			}
-		},
-		replyPipeline: {},
-		record: { onRecordError: (error) => {
-			throw error instanceof Error ? error : /* @__PURE__ */ new Error(`clickclack session record failed: ${String(error)}`);
-		} }
-	});
-	try {
-		await dispatchPromise;
-	} finally {
-		await activity?.finalize();
-	}
-}
-//#endregion
-//#region extensions/clickclack/src/gateway.ts
-const CLICKCLACK_EVENT_PAGE_LIMIT = 500;
-function payloadString(event, key) {
-	const value = event.payload?.[key];
-	return typeof value === "string" ? value : "";
-}
-function eventCorrelationId(event) {
-	return normalizeClickClackCorrelationId(event.payload?.correlation_id);
-}
-async function resolveEventMessage(params) {
-	const messageId = payloadString(params.event, "message_id");
-	if (!messageId) return null;
-	const directConversationId = payloadString(params.event, "direct_conversation_id");
-	if (directConversationId && typeof params.event.seq === "number") return (await params.client.directMessages(directConversationId, params.event.seq - 1, 10)).find((message) => message.id === messageId) ?? null;
-	if (params.event.type === "thread.reply_created") {
-		const rootId = payloadString(params.event, "root_message_id");
-		if (!rootId) return null;
-		return (await params.client.thread(rootId)).replies.find((message) => message.id === messageId) ?? null;
-	}
-	if (params.event.channel_id && typeof params.event.seq === "number") return (await params.client.channelMessages(params.event.channel_id, params.event.seq - 1, 10)).find((message) => message.id === messageId) ?? null;
-	return null;
-}
-function decodeSocketMessage(data) {
-	if (typeof data === "string") return data;
-	if (Buffer.isBuffer(data)) return data.toString("utf8");
-	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
-	return Buffer.concat(data).toString("utf8");
-}
-function parseSocketEvent(data) {
-	try {
-		return JSON.parse(decodeSocketMessage(data));
-	} catch {
-		return null;
-	}
-}
-async function processEvent(params) {
-	if (params.event.type !== "message.created" && params.event.type !== "thread.reply_created") return;
-	if (payloadString(params.event, "author_id") === params.botUserId) return;
-	const correlationId = eventCorrelationId(params.event);
-	const message = await resolveEventMessage({
-		client: correlationId ? createClickClackClient({
-			baseUrl: params.account.apiEndpoint,
-			token: params.account.token,
-			correlationId
-		}) : params.client,
-		event: params.event
-	});
-	if (!message || message.author_id === params.botUserId) return;
-	if (message.author?.kind === "bot") return;
-	const access = await resolveClickClackInboundAccess({
-		account: params.account,
-		config: params.config,
-		message
-	});
-	if (!access.shouldDispatch) return;
-	await handleClickClackInbound({
-		account: params.account,
-		config: params.config,
-		message,
-		access,
-		...correlationId ? { correlationId } : {}
-	});
-}
-async function drainEventBacklog(params) {
-	let afterCursor = params.afterCursor;
-	while (!params.abortSignal.aborted) {
-		const events = (await params.client.eventPage(params.workspaceId, {
-			afterCursor,
-			limit: CLICKCLACK_EVENT_PAGE_LIMIT
-		})).events;
-		for (const event of events) {
-			if (params.abortSignal.aborted) return afterCursor;
-			if (!event.cursor || event.cursor === afterCursor) throw new Error("ClickClack event backlog returned a non-advancing cursor");
-			await params.onEvent(event);
-			afterCursor = event.cursor;
-		}
-		if (events.length === 0) return afterCursor;
-	}
-	return afterCursor;
-}
-async function startClickClackGatewayAccount(ctx) {
-	const configuredAccount = resolveClickClackAccount({
-		cfg: ctx.cfg,
-		accountId: ctx.account.accountId
-	});
-	if (!configuredAccount.configured) throw new Error(`ClickClack is not configured for account "${configuredAccount.accountId}"`);
-	const client = createClickClackClient({
-		baseUrl: configuredAccount.apiEndpoint,
-		token: configuredAccount.token
-	});
-	const workspaceId = await resolveWorkspaceId(client, configuredAccount.workspace);
-	const me = await client.me();
-	const account = {
-		...configuredAccount,
-		workspace: workspaceId,
-		botUserId: configuredAccount.botUserId ?? me.id
-	};
-	const processIncomingEvent = (event) => processEvent({
-		account,
-		config: ctx.cfg,
-		client,
-		event,
-		botUserId: account.botUserId
-	});
-	if (account.commandMenu) await syncClickClackCommandMenu({
-		cfg: ctx.cfg,
-		client,
-		log: ctx.log
-	});
-	ctx.setStatus({
-		accountId: account.accountId,
-		running: true,
-		configured: true,
-		enabled: account.enabled,
-		baseUrl: account.baseUrl
-	});
-	let afterCursor = "";
-	let initialized = false;
-	try {
-		while (!ctx.abortSignal.aborted) {
-			if (!initialized) {
-				const page = await client.eventPage(workspaceId, { includeTail: true });
-				if (page.tailCursor !== void 0) afterCursor = page.tailCursor;
-				else for (const event of page.events) afterCursor = event.cursor || afterCursor;
-				initialized = true;
-			} else afterCursor = await drainEventBacklog({
-				client,
-				workspaceId,
-				afterCursor,
-				abortSignal: ctx.abortSignal,
-				onEvent: processIncomingEvent
-			});
-			if (ctx.abortSignal.aborted) break;
-			const socket = client.websocket(workspaceId, afterCursor);
-			await new Promise((resolve) => {
-				let settled = false;
-				let closing = false;
-				let loggedMessageFailure = false;
-				let messageQueue = Promise.resolve();
-				let removeAbortListener;
-				const finishSocketCycle = () => {
-					if (settled) return;
-					settled = true;
-					removeAbortListener?.();
-					removeAbortListener = void 0;
-					resolve();
-				};
-				const finishAfterQueuedMessages = () => {
-					messageQueue.then(() => finishSocketCycle(), () => finishSocketCycle());
-				};
-				const reconnectAfterMessageFailure = (error) => {
-					if (settled || ctx.abortSignal.aborted) return;
-					if (!loggedMessageFailure) {
-						loggedMessageFailure = true;
-						ctx.log?.warn?.(`[${account.accountId}] ClickClack event processing failed; reconnecting: ${error instanceof Error ? error.message : formatErrorMessage(error)}`);
-					}
-					if (!closing) {
-						closing = true;
-						socket.close();
-					}
-				};
-				const abort = () => {
-					socket.close();
-					finishSocketCycle();
-				};
-				ctx.abortSignal.addEventListener("abort", abort, { once: true });
-				removeAbortListener = () => ctx.abortSignal.removeEventListener("abort", abort);
-				socket.on("message", (data) => {
-					if (closing || settled) return;
-					messageQueue = messageQueue.then(async () => {
-						const event = parseSocketEvent(data);
-						if (!event) {
-							ctx.log?.warn?.(`[${account.accountId}] skipped malformed ClickClack websocket event`);
-							return;
-						}
-						await processIncomingEvent(event);
-						afterCursor = event.cursor || afterCursor;
-					});
-					messageQueue.catch(reconnectAfterMessageFailure);
-				});
-				socket.on("close", () => {
-					closing = true;
-					finishAfterQueuedMessages();
-				});
-				socket.on("error", (error) => {
-					if (settled || ctx.abortSignal.aborted) {
-						finishSocketCycle();
-						return;
-					}
-					if (closing) return;
-					ctx.log?.warn?.(`[${account.accountId}] ClickClack websocket error; reconnecting: ${error instanceof Error ? error.message : String(error)}`);
-					closing = true;
-					socket.close();
-				});
-			});
-			if (!ctx.abortSignal.aborted) try {
-				await sleepWithAbort(account.reconnectMs, ctx.abortSignal);
-			} catch (error) {
-				if (!ctx.abortSignal.aborted) throw error;
-			}
-		}
-	} finally {
-		ctx.setStatus({
-			accountId: account.accountId,
-			running: false
-		});
-	}
-}
-//#endregion
-//#region extensions/clickclack/src/channel.ts
-/**
-* ClickClack channel plugin definition: target parsing, account config, status,
-* gateway startup, and outbound delivery wiring.
-*/
-const CHANNEL_ID = CLICKCLACK_CHANNEL_ID;
-const clickClackMessageAdapter = defineChannelMessageAdapter({
-	id: CHANNEL_ID,
-	durableFinal: {
-		capabilities: {
-			text: true,
-			media: true,
-			replyTo: true,
-			thread: true,
-			messageSendingHooks: true,
-			reconcileUnknownSend: true
-		},
-		reconcileUnknownSendKinds: {
-			text: true,
-			media: true
-		},
-		reconcileUnknownSend: reconcileClickClackUnknownSend
-	},
-	send: {
-		text: async (ctx) => {
-			const messageId = await sendClickClackText({
-				cfg: ctx.cfg,
-				accountId: ctx.accountId,
-				to: ctx.to,
-				text: ctx.text,
-				threadId: ctx.threadId,
-				replyToId: ctx.replyToId,
-				deliveryQueueId: ctx.deliveryQueueId,
-				deliveryPartIndex: ctx.deliveryPartIndex,
-				onPlatformSendDispatch: ctx.onPlatformSendDispatch
-			});
-			const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
-			const replyToId = ctx.replyToId ?? void 0;
-			return {
-				...messageId ? { messageId } : {},
-				receipt: createMessageReceiptFromOutboundResults({
-					results: messageId ? [{
-						channel: CHANNEL_ID,
-						messageId
-					}] : [],
-					threadId,
-					replyToId,
-					kind: "text"
-				})
-			};
-		},
-		media: async (ctx) => {
-			const messageId = await sendClickClackMedia({
-				cfg: ctx.cfg,
-				accountId: ctx.accountId,
-				to: ctx.to,
-				text: ctx.text,
-				mediaUrl: ctx.mediaUrl,
-				mediaAccess: ctx.mediaAccess,
-				mediaLocalRoots: ctx.mediaLocalRoots,
-				mediaReadFile: ctx.mediaReadFile,
-				threadId: ctx.threadId,
-				replyToId: ctx.replyToId,
-				deliveryQueueId: ctx.deliveryQueueId,
-				deliveryPartIndex: ctx.deliveryPartIndex,
-				onPlatformSendDispatch: ctx.onPlatformSendDispatch
-			});
-			const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
-			const replyToId = ctx.replyToId ?? void 0;
-			return {
-				messageId,
-				receipt: createMessageReceiptFromOutboundResults({
-					results: [{
-						channel: CHANNEL_ID,
-						messageId
-					}],
-					threadId,
-					replyToId,
-					kind: "media"
-				})
-			};
-		}
-	}
-});
-/**
-* Channel plugin instance registered by the bundled ClickClack entry.
-*/
-const clickClackPlugin = createChatChannelPlugin({
-	base: {
-		id: CHANNEL_ID,
-		meta: clickClackMeta,
-		capabilities: {
-			chatTypes: ["direct", "group"],
-			threads: true,
-			blockStreaming: true
-		},
-		reload: { configPrefixes: ["channels.clickclack"] },
-		configSchema: clickClackConfigSchema,
-		config: clickClackConfigAdapter,
-		setup: clickClackSetupAdapter,
-		setupContract: clickClackSetupContract,
-		setupWizard: clickClackSetupWizard,
-		secrets: {
-			secretTargetRegistryEntries,
-			collectRuntimeConfigAssignments
-		},
-		messaging: {
-			targetPrefixes: ["clickclack", "cc"],
-			normalizeTarget: normalizeClickClackTarget,
-			inferTargetChatType: ({ to }) => parseClickClackTarget(to).chatType,
-			targetResolver: {
-				looksLikeId: looksLikeClickClackTarget,
-				hint: "<channel:name|dm:usr_id|thread:msg_id>"
-			},
-			resolveOutboundSessionRoute: ({ cfg, agentId, accountId, target, replyToId, threadId, currentSessionKey }) => {
-				const parsed = parseClickClackTarget(target);
-				return buildThreadAwareOutboundSessionRoute({
-					route: buildChannelOutboundSessionRoute({
-						cfg,
-						agentId,
-						channel: CHANNEL_ID,
-						accountId,
-						recipientSessionExact: parsed.kind === "dm",
-						peer: {
-							kind: parsed.chatType === "direct" ? "direct" : "channel",
-							id: buildClickClackTarget(parsed)
-						},
-						chatType: parsed.chatType,
-						from: `clickclack:${accountId ?? DEFAULT_ACCOUNT_ID}`,
-						to: buildClickClackTarget(parsed)
-					}),
-					replyToId,
-					threadId: threadId ?? (parsed.kind === "thread" ? parsed.id : void 0),
-					currentSessionKey,
-					useSuffix: false,
-					canRecoverCurrentThread: () => true
-				});
-			},
-			resolveSessionConversation: ({ rawId }) => {
-				const parsed = parseClickClackTarget(rawId);
-				if (parsed.kind === "dm") return null;
-				return {
-					id: parsed.id,
-					threadId: parsed.kind === "thread" ? parsed.id : void 0,
-					baseConversationId: parsed.id,
-					parentConversationCandidates: [parsed.id]
-				};
-			}
-		},
-		status: createComputedAccountStatusAdapter({
-			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-			buildChannelSummary: ({ snapshot }) => ({
-				ok: snapshot.configured,
-				label: snapshot.configured ? "configured" : "missing config",
-				detail: snapshot.baseUrl ?? ""
-			}),
-			resolveAccountSnapshot: ({ account }) => ({
-				accountId: account.accountId,
-				name: account.name,
-				enabled: account.enabled,
-				configured: account.configured,
-				baseUrl: account.baseUrl
-			})
-		}),
-		gateway: { startAccount: startClickClackGatewayAccount },
-		message: clickClackMessageAdapter
-	},
-	outbound: {
-		base: { deliveryMode: "direct" },
-		attachedResults: {
-			channel: CHANNEL_ID,
-			sendText: async ({ cfg, to, text, accountId, threadId, replyToId, deliveryQueueId, deliveryPartIndex, onPlatformSendDispatch }) => {
-				return { messageId: await sendClickClackText({
-					cfg,
-					accountId,
-					to,
-					text,
-					threadId,
-					replyToId,
-					deliveryQueueId,
-					deliveryPartIndex,
-					onPlatformSendDispatch
-				}) ?? "" };
-			},
-			sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, threadId, replyToId, deliveryQueueId, deliveryPartIndex, onPlatformSendDispatch }) => {
-				if (!mediaUrl) throw new Error("ClickClack media send requires mediaUrl");
-				return { messageId: await sendClickClackMedia({
-					cfg,
-					accountId,
-					to,
-					text,
-					mediaUrl,
-					mediaAccess,
-					mediaLocalRoots,
-					mediaReadFile,
-					threadId,
-					replyToId,
-					deliveryQueueId,
-					deliveryPartIndex,
-					onPlatformSendDispatch
-				}) };
-			}
-		}
-	}
-});
-//#endregion
-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 };