@openclaw/clickclack 2026.7.2-beta.7 → 2026.7.33

package/dist/runtime-api-CZ1rmHjv.js

@@ -1,1029 +0,0 @@
-import { d as createClickClackClient, f as isClickClackChannelNameConflict, u as ClickClackHttpError, x as resolveClickClackAccount, y as listClickClackAccountIds } from "./setup-surface-DAy8vDJK.js";
-import { C as truncateDiscussionDisplayTitle, D as reserveDiscussionBindingGeneration, E as recordPendingDiscussionOpen, S as slugifyDiscussionLabel, T as listPendingDiscussionOpens, _ as discussionCredentialFingerprint, b as isDiscussionSessionKey, c as markClickClackDiscussionChannelIdentityRevoked, d as discussionInfoForBinding, f as normalizedServerBaseUrl, g as getClickClackDiscussionBindingStore, h as bindingMatchesSessionIncarnation, l as markClickClackDiscussionChannelRevoked, m as bindingMatchesActiveSessionIncarnation, o as clearClickClackDiscussionChannelRevoked, p as resolveDiscussionBindingAccount, s as isClickClackDiscussionChannelRevoked, u as discussionAccounts, v as discussionExternalRef, w as clearDiscussionBindingGeneration, x as resolveDiscussionLabel, y as fallbackDiscussionLabel } from "./channel-CECIpaS0.js";
-import "./api.js";
-import { resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
-import { randomUUID } from "node:crypto";
-import { registerSessionDiscussionProvider } from "openclaw/plugin-sdk/session-discussion";
-import { createSessionVisibilityChecker } from "openclaw/plugin-sdk/session-visibility";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
-import { textResult } from "openclaw/plugin-sdk/tool-results";
-//#region extensions/clickclack/src/discussions/control-session-url.ts
-const SESSION_UUID_SUFFIX_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/iu;
-const SHORT_SESSION_REF_RE = /^(?:.*-)?([0-9a-f]{8,32})$/iu;
-const VALID_AGENT_ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/iu;
-const INVALID_AGENT_ID_CHARS_RE = /[^a-z0-9_-]+/giu;
-const FIXED_RESERVED_SESSION_RESTS = /* @__PURE__ */ new Set([
-	"main",
-	"global",
-	"boot",
-	"sessions"
-]);
-const SESSION_SLUG_MAX_LENGTH = 48;
-const DEFAULT_AGENT_ID = "main";
-const DEFAULT_MAIN_KEY = "main";
-function optionalString(value) {
-	return (value?.trim() ?? "") || null;
-}
-function normalizeAgentId$1(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return DEFAULT_AGENT_ID;
-	if (VALID_AGENT_ID_RE.test(trimmed)) return trimmed.toLowerCase();
-	return trimmed.toLowerCase().replace(INVALID_AGENT_ID_CHARS_RE, "-").replace(/^-+|-+$/gu, "").slice(0, 64) || DEFAULT_AGENT_ID;
-}
-function normalizeBasePath(basePath) {
-	const trimmed = basePath.trim().replace(/^\/+|\/+$/gu, "");
-	return trimmed ? `/${trimmed}` : "";
-}
-function agentSessionKeyParts(sessionKey) {
-	const parts = sessionKey.split(":");
-	if (parts.length < 3 || parts[0]?.toLowerCase() !== "agent") return null;
-	const agentId = optionalString(parts[1]);
-	const restSegments = parts.slice(2);
-	if (!agentId || restSegments.some((segment) => !segment)) return null;
-	return {
-		agentId: normalizeAgentId$1(agentId),
-		rest: restSegments.join(":")
-	};
-}
-function encodePathSegment(segment) {
-	if (segment === ".") return "~dot";
-	if (segment === "..") return "~dotdot";
-	const encoded = encodeURIComponent(segment).replaceAll(".", "%2E");
-	return encoded.startsWith("~") ? `~${encoded}` : encoded;
-}
-function isReservedSessionRest(rest, mainKey) {
-	const normalized = rest.toLowerCase();
-	return FIXED_RESERVED_SESSION_RESTS.has(normalized) || normalized === (optionalString(mainKey)?.toLowerCase() ?? DEFAULT_MAIN_KEY);
-}
-function sessionSlug(displayName) {
-	const tokens = (displayName ?? "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").split("-").filter(Boolean);
-	while (tokens.length > 0 && /^[0-9a-f]+$/u.test(tokens.at(-1) ?? "")) tokens.pop();
-	return tokens.join("-").slice(0, SESSION_SLUG_MAX_LENGTH).replace(/-+$/gu, "");
-}
-function sessionKeyUuid(sessionKey) {
-	const uuid = (agentSessionKeyParts(sessionKey)?.rest)?.match(SESSION_UUID_SUFFIX_RE)?.[1];
-	return uuid ? uuid.toLowerCase().replaceAll("-", "") : null;
-}
-function sessionPath(params) {
-	const rawKey = optionalString(params.sessionKey);
-	const parsed = rawKey ? agentSessionKeyParts(rawKey) : null;
-	const fallbackAgentId = optionalString(params.fallbackAgentId);
-	const agentId = parsed?.agentId ?? (fallbackAgentId ? normalizeAgentId$1(fallbackAgentId) : null);
-	if (!rawKey || !agentId || !parsed && rawKey.toLowerCase().startsWith("agent:")) return null;
-	const namespace = `${normalizeBasePath(params.basePath)}/chat`;
-	const encodedAgentId = encodePathSegment(agentId);
-	const rest = parsed?.rest ?? rawKey;
-	const normalizedRest = rest.toLowerCase();
-	const mainKey = optionalString(params.mainKey)?.toLowerCase() ?? DEFAULT_MAIN_KEY;
-	if (!parsed && normalizedRest === DEFAULT_MAIN_KEY || normalizedRest === mainKey || normalizedRest === "global") return `${namespace}/${encodedAgentId}`;
-	const uuid = parsed ? sessionKeyUuid(rawKey) : null;
-	if (uuid) {
-		let length = 8;
-		const slug = sessionSlug(params.displayName);
-		let sessionRef = `${slug ? `${slug}-` : ""}${uuid.slice(0, length)}`;
-		while (length < uuid.length && isReservedSessionRest(sessionRef, params.mainKey)) {
-			length += 1;
-			sessionRef = `${slug ? `${slug}-` : ""}${uuid.slice(0, length)}`;
-		}
-		return isReservedSessionRest(sessionRef, params.mainKey) ? null : `${namespace}/${encodedAgentId}/${sessionRef}`;
-	}
-	const segments = rest.split(":");
-	if (segments.some((segment) => !segment)) return null;
-	if (segments.length === 1) {
-		const segment = segments[0] ?? "";
-		if (!isReservedSessionRest(segment, params.mainKey) && SHORT_SESSION_REF_RE.test(segment)) return `${namespace}/${encodedAgentId}/~key/${encodePathSegment(segment)}`;
-	}
-	return `${namespace}/${encodedAgentId}/${segments.map(encodePathSegment).join("/")}`;
-}
-function controlSessionUrl(baseUrl, sessionKey, fallbackAgentId, mainKey, displayName) {
-	if (!baseUrl) return;
-	const url = new URL(baseUrl);
-	const path = sessionPath({
-		sessionKey,
-		fallbackAgentId,
-		basePath: url.pathname,
-		displayName,
-		mainKey
-	});
-	if (!path) return;
-	url.pathname = path;
-	url.hash = "";
-	return url.toString();
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/history-format.ts
-function discussionRecordJson(value) {
-	return JSON.stringify(value).replace(/[\u0085\u2028\u2029]/gu, (separator) => `\\u${separator.charCodeAt(0).toString(16).padStart(4, "0")}`);
-}
-/** Renders channel history as line-per-message records for the discussion tool. */
-function formatDiscussionHistory(history) {
-	const text = history.messages.map((message) => {
-		const author = message.author?.display_name || message.author?.handle || message.author_id || "Unknown";
-		return `timestamp=${discussionRecordJson(message.created_at)} [Author ${discussionRecordJson(author)} id=${discussionRecordJson(message.author_id)}] text=${discussionRecordJson(message.body)}`;
-	}).join("\n");
-	const truncationNote = history.truncated ? "\n[History scan reached its safety bound; older active threads may be omitted.]" : "";
-	return text ? `${text}${truncationNote}` : "";
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/installation.ts
-const INSTALLATION_NAMESPACE = "discussion-installation";
-const INSTALLATION_KEY = "current";
-/** Returns the durable installation namespace used in server-visible ownership refs. */
-function getClickClackDiscussionInstallationId(runtime) {
-	const store = runtime.state.openSyncKeyedStore({
-		namespace: INSTALLATION_NAMESPACE,
-		maxEntries: 1,
-		overflowPolicy: "reject-new"
-	});
-	const existing = store.lookup(INSTALLATION_KEY)?.id;
-	if (existing) return existing;
-	const id = randomUUID();
-	store.registerIfAbsent(INSTALLATION_KEY, { id });
-	return store.lookup(INSTALLATION_KEY)?.id ?? id;
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/reconcile-scheduler.ts
-const RECONCILE_DEBOUNCE_MS = 250;
-const RECONCILE_RETRY_MS = 1e3;
-const RECONCILE_RETRY_MAX_MS = 6e4;
-/**
-* Per-session debounced reconcile scheduling with failure backoff.
-* Contracts: bursts coalesce onto the earliest scheduled run (steady event
-* traffic can never postpone one); a failed run sets a not-before floor with
-* growing backoff that later events cannot undercut; events during an
-* in-flight run collapse into one follow-up scheduled after settlement; and
-* `supersede()` invalidates callbacks from earlier activations so stop/start
-* cycles cannot corrupt the bookkeeping of the next one.
-*/
-var DiscussionReconcileScheduler = class {
-	#hooks;
-	#timers = /* @__PURE__ */ new Map();
-	#retryState = /* @__PURE__ */ new Map();
-	#inFlight = /* @__PURE__ */ new Set();
-	#followUps = /* @__PURE__ */ new Set();
-	#generation = 0;
-	constructor(hooks) {
-		this.#hooks = hooks;
-	}
-	/** Invalidates callbacks scheduled by prior activations. */
-	supersede() {
-		this.#generation += 1;
-	}
-	clear() {
-		for (const scheduled of this.#timers.values()) clearTimeout(scheduled.timer);
-		this.#timers.clear();
-		this.#retryState.clear();
-		this.#inFlight.clear();
-		this.#followUps.clear();
-	}
-	schedule(sessionKey, delayMs = RECONCILE_DEBOUNCE_MS) {
-		if (!this.#hooks.shouldSchedule(sessionKey)) return;
-		if (this.#inFlight.has(sessionKey)) {
-			this.#followUps.add(sessionKey);
-			return;
-		}
-		const retry = this.#retryState.get(sessionKey);
-		const fireAt = Math.max(Date.now() + delayMs, retry?.notBefore ?? 0);
-		const existing = this.#timers.get(sessionKey);
-		if (existing) {
-			if (existing.fireAt <= fireAt) return;
-			clearTimeout(existing.timer);
-		}
-		const generation = this.#generation;
-		const timer = setTimeout(() => {
-			if (generation !== this.#generation) return;
-			this.#timers.delete(sessionKey);
-			this.#inFlight.add(sessionKey);
-			this.#hooks.run(sessionKey).then(() => {
-				if (generation !== this.#generation) return;
-				this.#retryState.delete(sessionKey);
-			}, (error) => {
-				if (generation !== this.#generation || !this.#hooks.shouldSchedule(sessionKey)) return;
-				const previous = this.#retryState.get(sessionKey);
-				const nextRetryMs = Math.min(previous === void 0 ? RECONCILE_RETRY_MS : previous.delayMs * 2, RECONCILE_RETRY_MAX_MS);
-				this.#retryState.set(sessionKey, {
-					delayMs: nextRetryMs,
-					notBefore: Date.now() + nextRetryMs
-				});
-				this.#hooks.warn(`discussion event reconcile failed for ${sessionKey}; retrying in ${nextRetryMs}ms: ${String(error)}`);
-				this.#followUps.add(sessionKey);
-			}).finally(() => {
-				if (generation !== this.#generation) return;
-				this.#inFlight.delete(sessionKey);
-				if (this.#followUps.delete(sessionKey)) this.schedule(sessionKey);
-			});
-		}, Math.max(fireAt - Date.now(), 0));
-		timer.unref?.();
-		this.#timers.set(sessionKey, {
-			fireAt,
-			timer
-		});
-	}
-};
-//#endregion
-//#region extensions/clickclack/src/discussions/service-open.ts
-const CHANNEL_NAME_MUTATION_ATTEMPTS$1 = 4;
-function isDefinitiveNoCreateHttpError(error) {
-	if (!(error instanceof ClickClackHttpError) || error.status < 400 || error.status >= 500) return false;
-	return ![
-		408,
-		409,
-		425,
-		429
-	].includes(error.status);
-}
-async function resolveAvailableChannelName(params) {
-	const desired = slugifyDiscussionLabel(params.label, params.sessionKey);
-	const channels = params.channels ?? await params.client.channels(params.workspaceId);
-	const occupied = new Set(channels.filter((channel) => channel.id !== params.ownChannelId).map((channel) => channel.name));
-	if (!occupied.has(desired)) return desired;
-	for (let suffix = 2; suffix <= 20; suffix += 1) {
-		const candidate = `${desired}-${suffix}`;
-		if (!occupied.has(candidate)) return candidate;
-	}
-	const fallback = fallbackDiscussionLabel(params.sessionKey, params.agentId);
-	if (!occupied.has(fallback)) return fallback;
-	for (let suffix = 2;; suffix += 1) {
-		const candidate = `${fallback}-${suffix}`;
-		if (!occupied.has(candidate)) return candidate;
-	}
-}
-function assertChannelPatch(channel, patch) {
-	for (const key of [
-		"archived",
-		"external_managed",
-		"external_ref",
-		"external_url",
-		"display_title",
-		"name",
-		"sidebar_section"
-	]) {
-		const expected = patch[key];
-		if (expected === void 0) continue;
-		if (key === "display_title" && !(key in channel)) continue;
-		if ((key === "external_ref" || key === "external_url" || key === "sidebar_section" ? channel[key] ?? "" : channel[key]) !== expected) throw new Error(`ClickClack channel update did not apply ${key}`);
-	}
-}
-function assertManagedChannelContract(channel, expected) {
-	const displayTitleMatches = !("display_title" in channel) || channel.display_title === expected.displayTitle;
-	if (channel.external_managed !== true || (channel.external_ref ?? "") !== (expected.externalRef ?? "") || (channel.sidebar_section ?? "") !== (expected.section ?? "") || (channel.external_url ?? "") !== (expected.externalUrl ?? "") || !displayTitleMatches) throw new Error(`ClickClack server does not support the managed discussion channel contract for ${expected.sessionKey}`);
-}
-function assertManagedChannelListContract(channels) {
-	if (channels.some((channel) => typeof channel.external_managed !== "boolean" || channel.external_ref !== void 0 && typeof channel.external_ref !== "string" || channel.external_url !== void 0 && typeof channel.external_url !== "string" || channel.sidebar_section !== void 0 && typeof channel.sidebar_section !== "string")) throw new Error("ClickClack server does not advertise the managed discussion contract");
-}
-async function openClickClackDiscussionBinding(params) {
-	const { account, runtime, sessionKey, store } = params;
-	const entry = runtime.agent.session.getSessionEntry({
-		sessionKey,
-		readConsistency: "latest"
-	});
-	if (!entry) return;
-	if (!entry.sessionId?.trim()) throw new Error("OpenClaw session does not yet have a concrete session id");
-	const client = params.clientFactory(account);
-	const workspace = (await client.workspaces()).find((candidate) => candidate.id === account.discussions.workspace || candidate.slug === account.discussions.workspace || candidate.name === account.discussions.workspace);
-	if (!workspace) throw new Error(`ClickClack discussions workspace not found: ${account.discussions.workspace}`);
-	if (!workspace.route_id) throw new Error("ClickClack discussions workspace is missing its route id");
-	const serverBaseUrl = normalizedServerBaseUrl(account);
-	const credentialFingerprint = discussionCredentialFingerprint(account.token);
-	const unresolved = listPendingDiscussionOpens(runtime).find((pending) => pending.sessionKey === sessionKey);
-	if (unresolved && (unresolved.accountId !== account.accountId || unresolved.credentialFingerprint !== credentialFingerprint || unresolved.sessionId !== entry.sessionId || unresolved.serverBaseUrl !== serverBaseUrl || unresolved.workspaceId !== workspace.id)) {
-		await params.reconcilePendingOpen(unresolved);
-		if (listPendingDiscussionOpens(runtime).some((pending) => pending.sessionKey === sessionKey)) throw new Error("A previous ClickClack discussion open is still unresolved; restore its credential and retry");
-	}
-	const config = runtime.config.current();
-	const agentId = resolveAgentIdFromSessionKey(sessionKey, resolveDefaultAgentId(config));
-	const fallback = fallbackDiscussionLabel(sessionKey, agentId);
-	const label = resolveDiscussionLabel(entry, sessionKey, agentId);
-	const displayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
-	const section = entry.category?.trim() || account.discussions.section;
-	const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? "main", config.session?.mainKey, label);
-	const archived = entry.archivedAt !== void 0;
-	return await params.withChannelMutationLock(async () => {
-		if (!store.hasCapacity(sessionKey)) throw new Error("ClickClack discussion binding capacity is exhausted");
-		let channels = await client.channels(workspace.id);
-		assertManagedChannelListContract(channels);
-		const destinationIdentity = [serverBaseUrl, workspace.id].join("\0");
-		const bindingGeneration = reserveDiscussionBindingGeneration({
-			runtime,
-			sessionKey,
-			destinationIdentity,
-			createGeneration: params.bindingGenerationFactory
-		});
-		const externalRef = discussionExternalRef(params.installationId, sessionKey, entry.sessionId, destinationIdentity, bindingGeneration);
-		let adopted;
-		let managedFields;
-		let resolved;
-		for (let attempt = 0; attempt < CHANNEL_NAME_MUTATION_ATTEMPTS$1; attempt += 1) {
-			adopted = channels.find((candidate) => candidate.external_managed === true && candidate.external_ref === externalRef);
-			managedFields = {
-				name: await resolveAvailableChannelName({
-					client,
-					workspaceId: workspace.id,
-					label,
-					sessionKey,
-					agentId,
-					channels,
-					ownChannelId: adopted?.id
-				}),
-				external_managed: true,
-				external_ref: externalRef,
-				external_url: externalUrl ?? "",
-				sidebar_section: section,
-				display_title: displayTitle
-			};
-			recordPendingDiscussionOpen({
-				runtime,
-				sessionKey,
-				generation: bindingGeneration,
-				pending: {
-					accountId: account.accountId,
-					serverBaseUrl,
-					workspaceId: workspace.id,
-					sessionId: entry.sessionId,
-					externalRef,
-					credentialFingerprint
-				}
-			});
-			params.ensureTimer();
-			try {
-				if (adopted) {
-					markClickClackDiscussionChannelIdentityRevoked({
-						runtime,
-						accountId: account.accountId,
-						serverBaseUrl,
-						channelId: adopted.id
-					});
-					resolved = await client.updateChannel(adopted.id, {
-						...managedFields,
-						archived
-					});
-				} else {
-					resolved = await client.createChannel(workspace.id, {
-						...managedFields,
-						kind: "public"
-					});
-					markClickClackDiscussionChannelIdentityRevoked({
-						runtime,
-						accountId: account.accountId,
-						serverBaseUrl,
-						channelId: resolved.id
-					});
-				}
-				break;
-			} catch (error) {
-				if (isClickClackChannelNameConflict(error) && attempt < CHANNEL_NAME_MUTATION_ATTEMPTS$1 - 1) {
-					channels = await client.channels(workspace.id);
-					assertManagedChannelListContract(channels);
-					continue;
-				}
-				const definitiveNoCreate = isDefinitiveNoCreateHttpError(error);
-				try {
-					const relisted = await client.channels(workspace.id);
-					assertManagedChannelListContract(relisted);
-					const recovered = relisted.find((candidate) => candidate.external_managed === true && candidate.external_ref === externalRef);
-					if (recovered) {
-						adopted = recovered;
-						markClickClackDiscussionChannelIdentityRevoked({
-							runtime,
-							accountId: account.accountId,
-							serverBaseUrl,
-							channelId: recovered.id
-						});
-						resolved = await client.updateChannel(recovered.id, {
-							...managedFields,
-							archived
-						});
-						break;
-					}
-					if (definitiveNoCreate) clearDiscussionBindingGeneration({
-						runtime,
-						sessionKey,
-						expectedGeneration: bindingGeneration
-					});
-				} catch {
-					if (definitiveNoCreate && !adopted) clearDiscussionBindingGeneration({
-						runtime,
-						sessionKey,
-						expectedGeneration: bindingGeneration
-					});
-				}
-				throw error;
-			}
-		}
-		if (!resolved || !managedFields) throw new Error("ClickClack discussion channel name retries were exhausted");
-		try {
-			assertManagedChannelContract(resolved, {
-				sessionKey,
-				externalRef,
-				section,
-				externalUrl,
-				displayTitle
-			});
-			if (adopted) assertChannelPatch(resolved, {
-				...managedFields,
-				archived
-			});
-		} catch (error) {
-			try {
-				assertChannelPatch(await client.updateChannel(resolved.id, { archived: true }), { archived: true });
-				clearDiscussionBindingGeneration({
-					runtime,
-					sessionKey,
-					expectedGeneration: bindingGeneration
-				});
-			} catch (archiveError) {
-				params.warn(`failed to archive incompatible discussion channel ${resolved.id}: ${String(archiveError)}`);
-			}
-			throw error;
-		}
-		if (!resolved.route_id) {
-			try {
-				assertChannelPatch(await client.updateChannel(resolved.id, { archived: true }), { archived: true });
-				clearDiscussionBindingGeneration({
-					runtime,
-					sessionKey,
-					expectedGeneration: bindingGeneration
-				});
-			} catch (archiveError) {
-				params.warn(`failed to archive route-less discussion channel ${resolved.id}: ${String(archiveError)}`);
-			}
-			throw new Error("ClickClack discussion channel is missing its route id");
-		}
-		let channel = resolved;
-		if (!adopted && archived) {
-			channel = await client.updateChannel(resolved.id, { archived: true });
-			assertChannelPatch(channel, { archived: true });
-		}
-		const nextBinding = {
-			accountId: account.accountId,
-			agentId,
-			sessionId: entry.sessionId,
-			serverBaseUrl,
-			credentialFingerprint,
-			externalRef,
-			externalUrl: externalUrl ?? "",
-			workspaceRef: account.discussions.workspace,
-			workspaceId: workspace.id,
-			channelId: channel.id,
-			channelRouteId: channel.route_id,
-			workspaceRouteId: workspace.route_id,
-			section,
-			archived,
-			label,
-			displayTitle: "display_title" in channel ? channel.display_title : void 0
-		};
-		const currentEntry = runtime.agent.session.getSessionEntry({
-			sessionKey,
-			readConsistency: "latest"
-		});
-		if (!currentEntry || currentEntry.sessionId !== entry.sessionId) {
-			try {
-				assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
-				clearDiscussionBindingGeneration({
-					runtime,
-					sessionKey,
-					expectedGeneration: bindingGeneration
-				});
-			} catch (archiveError) {
-				params.warn(`failed to archive superseded discussion channel ${channel.id}: ${String(archiveError)}`);
-			}
-			throw new Error("OpenClaw session changed while opening its ClickClack discussion");
-		}
-		try {
-			store.set(sessionKey, nextBinding);
-		} catch (error) {
-			try {
-				assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
-				clearDiscussionBindingGeneration({
-					runtime,
-					sessionKey,
-					expectedGeneration: bindingGeneration
-				});
-			} catch (archiveError) {
-				params.warn(`failed to archive unbound discussion channel ${channel.id}: ${String(archiveError)}`);
-			}
-			throw error;
-		}
-		params.finalizePendingBinding(sessionKey, nextBinding);
-		return nextBinding;
-	});
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/service.ts
-const RECONCILE_INTERVAL_MS = 6e4;
-const CHANNEL_NAME_MUTATION_ATTEMPTS = 4;
-var ClickClackDiscussionService = class {
-	#runtime;
-	#store;
-	#clientFactory;
-	#installationId;
-	#bindingGenerationFactory;
-	#timersEnabled;
-	#sessionLocks = /* @__PURE__ */ new Map();
-	#reconcileScheduler = new DiscussionReconcileScheduler({
-		shouldSchedule: (sessionKey) => !this.#closed && (this.#store.get(sessionKey) !== void 0 || listPendingDiscussionOpens(this.#runtime).some((pending) => pending.sessionKey === sessionKey)),
-		run: async (sessionKey) => await this.reconcile(sessionKey),
-		warn: (message) => this.#logger().warn(message)
-	});
-	#channelMutationLock = Promise.resolve();
-	#timer;
-	#reconcileAllPromise;
-	#unsubscribeSessionsChanged;
-	#closed = false;
-	constructor(runtime, options = {}) {
-		this.#runtime = runtime;
-		this.#store = getClickClackDiscussionBindingStore(runtime);
-		this.#clientFactory = options.clientFactory ?? ((account) => createClickClackClient({
-			baseUrl: account.apiEndpoint,
-			token: account.token
-		}));
-		this.#installationId = options.installationId ?? getClickClackDiscussionInstallationId(runtime);
-		this.#bindingGenerationFactory = options.bindingGenerationFactory ?? randomUUID;
-		this.#timersEnabled = options.startTimer !== false;
-		this.provider = {
-			id: "clickclack",
-			info: async ({ sessionKey }) => await this.info(sessionKey),
-			open: async ({ sessionKey }) => await this.open(sessionKey)
-		};
-		if (options.gatewayEvents) this.bindGatewayEvents(options.gatewayEvents);
-		if (this.#timersEnabled) this.#ensureTimer();
-	}
-	bindGatewayEvents(gatewayEvents) {
-		this.#unsubscribeSessionsChanged?.();
-		this.#closed = false;
-		this.#reconcileScheduler.supersede();
-		this.#unsubscribeSessionsChanged = gatewayEvents?.onSessionsChanged((event) => {
-			this.#reconcileScheduler.schedule(event.sessionKey);
-		});
-		for (const sessionKey of this.#listReconcileSessionKeys()) this.#reconcileScheduler.schedule(sessionKey, 0);
-		if (this.#timersEnabled) this.#ensureTimer();
-	}
-	hasEnabledAccount() {
-		return discussionAccounts(this.#currentConfig()).length === 1;
-	}
-	async info(sessionKey) {
-		return await this.#withSessionLock(sessionKey, async () => {
-			if (discussionAccounts(this.#currentConfig()).length !== 1) return { state: "none" };
-			const existing = this.#store.get(sessionKey);
-			if (existing) {
-				const resolved = await this.#resolveBindingForUse(existing);
-				if (resolved.state === "retargeted") {
-					this.#revokeAndDeleteBinding(sessionKey, existing);
-					return { state: "available" };
-				}
-				if (resolved.state === "stale") {
-					await this.#releaseStaleBinding(sessionKey, existing);
-					return { state: "available" };
-				}
-				if (resolved.state !== "active") return { state: "none" };
-				this.#finalizePendingBinding(sessionKey, existing);
-				await this.#reconcileBinding(sessionKey, existing, resolved.account);
-				const current = this.#store.get(sessionKey);
-				if (!current) return { state: this.hasEnabledAccount() ? "available" : "none" };
-				return discussionInfoForBinding(current, resolved.account);
-			}
-			return { state: "available" };
-		});
-	}
-	async open(sessionKey) {
-		return await this.#withSessionLock(sessionKey, async () => {
-			const accounts = discussionAccounts(this.#currentConfig());
-			if (accounts.length > 1) throw new Error("ClickClack discussions require exactly one enabled discussion account");
-			const account = accounts[0];
-			if (!account) return { state: "none" };
-			const existing = this.#store.get(sessionKey);
-			if (existing) {
-				const resolved = await this.#resolveBindingForUse(existing);
-				if (resolved.state === "retargeted") this.#revokeAndDeleteBinding(sessionKey, existing);
-				else if (resolved.state === "stale") await this.#releaseStaleBinding(sessionKey, existing);
-				else if (resolved.state === "active") {
-					this.#finalizePendingBinding(sessionKey, existing);
-					await this.#reconcileBinding(sessionKey, existing, resolved.account);
-					const current = this.#store.get(sessionKey);
-					if (current) return discussionInfoForBinding(current, resolved.account);
-				}
-			}
-			let binding;
-			try {
-				binding = await openClickClackDiscussionBinding({
-					runtime: this.#runtime,
-					store: this.#store,
-					account,
-					clientFactory: this.#clientFactory,
-					installationId: this.#installationId,
-					bindingGenerationFactory: this.#bindingGenerationFactory,
-					sessionKey,
-					ensureTimer: () => this.#ensureTimer(),
-					reconcilePendingOpen: async (pending) => await this.#reconcilePendingOpen(pending, { allowRetry: false }),
-					withChannelMutationLock: async (run) => await this.#withChannelMutationLock(run),
-					finalizePendingBinding: (key, nextBinding) => this.#finalizePendingBinding(key, nextBinding),
-					warn: (message) => this.#logger().warn(message)
-				});
-			} finally {
-				this.#ensureTimer();
-			}
-			if (!binding) return { state: "available" };
-			return discussionInfoForBinding(binding, account);
-		});
-	}
-	async reconcile(sessionKey) {
-		try {
-			await this.#withSessionLock(sessionKey, async () => {
-				const binding = this.#store.get(sessionKey);
-				if (binding) await this.#reconcileBinding(sessionKey, binding);
-			});
-			const pending = listPendingDiscussionOpens(this.#runtime).find((candidate) => candidate.sessionKey === sessionKey);
-			if (pending) await this.#reconcilePendingOpen(pending);
-		} finally {
-			this.#ensureTimer();
-		}
-	}
-	async reconcileAll() {
-		if (this.#reconcileAllPromise) return await this.#reconcileAllPromise;
-		this.#reconcileAllPromise = (async () => {
-			for (const sessionKey of this.#listReconcileSessionKeys()) try {
-				await this.reconcile(sessionKey);
-			} catch (error) {
-				this.#logger().warn(`discussion reconcile failed for ${sessionKey}: ${String(error)}`);
-			}
-		})().finally(() => {
-			this.#reconcileAllPromise = void 0;
-		});
-		return await this.#reconcileAllPromise;
-	}
-	async readLatestMessages(sessionKey, limit) {
-		const binding = this.#store.get(sessionKey);
-		if (!binding) return { text: "No discussion is bound to this session." };
-		const resolved = await this.#resolveBindingForUse(binding);
-		if (resolved.state === "retargeted") return { text: "No discussion is bound to this session." };
-		if (resolved.state === "stale") return { text: "No discussion is bound to this session." };
-		if (resolved.state !== "active") return { text: "No discussion is bound to this session." };
-		if (!bindingMatchesSessionIncarnation(this.#runtime, sessionKey, binding)) return { text: "No discussion is bound to this session." };
-		if (isClickClackDiscussionChannelRevoked({
-			runtime: this.#runtime,
-			serverBaseUrl: binding.serverBaseUrl,
-			channelId: binding.channelId
-		})) return { text: "No discussion is bound to this session." };
-		return {
-			binding,
-			text: formatDiscussionHistory(await this.#clientFactory(resolved.account).latestChannelMessages(binding.channelId, limit)) || "The bound discussion has no messages yet."
-		};
-	}
-	cleanup() {
-		this.#closed = true;
-		this.#unsubscribeSessionsChanged?.();
-		this.#unsubscribeSessionsChanged = void 0;
-		this.#reconcileScheduler.supersede();
-		this.#reconcileScheduler.clear();
-		if (this.#timer) {
-			clearInterval(this.#timer);
-			this.#timer = void 0;
-		}
-	}
-	async #reconcileBinding(sessionKey, binding, resolvedAccount) {
-		this.#finalizePendingBinding(sessionKey, binding);
-		if (isClickClackDiscussionChannelRevoked({
-			runtime: this.#runtime,
-			serverBaseUrl: binding.serverBaseUrl,
-			channelId: binding.channelId
-		})) {
-			this.#store.delete(sessionKey);
-			return;
-		}
-		const resolved = resolvedAccount ? {
-			state: "active",
-			account: resolvedAccount
-		} : await this.#resolveBindingForUse(binding);
-		if (resolved.state === "retargeted") {
-			this.#revokeAndDeleteBinding(sessionKey, binding);
-			return;
-		}
-		if (resolved.state === "stale") {
-			await this.#releaseStaleBinding(sessionKey, binding);
-			return;
-		}
-		if (resolved.state !== "active") return;
-		const account = resolved.account;
-		if (!account.baseUrl || !account.token) throw new Error(`ClickClack discussion account is no longer configured: ${binding.accountId}`);
-		const entry = this.#runtime.agent.session.getSessionEntry({
-			sessionKey,
-			readConsistency: "latest"
-		});
-		if (entry && (!binding.sessionId || entry.sessionId !== binding.sessionId)) {
-			await this.#archiveAndDeleteBinding(sessionKey, binding, account);
-			return;
-		}
-		const archived = entry ? entry.archivedAt !== void 0 : true;
-		const deleted = entry === void 0;
-		const fallback = fallbackDiscussionLabel(sessionKey, binding.agentId);
-		const label = entry ? resolveDiscussionLabel(entry, sessionKey, binding.agentId) : binding.label;
-		const section = entry?.category?.trim() || account.discussions.section;
-		const externalUrl = controlSessionUrl(account.discussions.controlUrlBase, sessionKey, account.agentId ?? "main", this.#currentConfig().session?.mainKey, label) ?? "";
-		const patch = {};
-		if (archived !== binding.archived) patch.archived = archived;
-		const labelChanged = label !== binding.label;
-		const desiredDisplayTitle = label === fallback ? "" : truncateDiscussionDisplayTitle(label);
-		const serverSupportsDisplayTitle = this.#store.entries().some(({ binding: candidate }) => candidate.displayTitle !== void 0 && candidate.serverBaseUrl === binding.serverBaseUrl && candidate.accountId === binding.accountId);
-		const shouldBackfillDisplayTitle = desiredDisplayTitle !== "" && binding.displayTitle !== desiredDisplayTitle && serverSupportsDisplayTitle;
-		if (labelChanged || shouldBackfillDisplayTitle) patch.display_title = desiredDisplayTitle;
-		if (section !== binding.section) patch.sidebar_section = section;
-		if (externalUrl !== binding.externalUrl) patch.external_url = externalUrl;
-		if (Object.keys(patch).length === 0 && !labelChanged) {
-			if (deleted) this.#revokeAndDeleteBinding(sessionKey, binding);
-			return;
-		}
-		const client = this.#clientFactory(account);
-		let updated;
-		if (labelChanged) updated = await this.#withChannelMutationLock(async () => {
-			for (let attempt = 0; attempt < CHANNEL_NAME_MUTATION_ATTEMPTS; attempt += 1) {
-				patch.name = await resolveAvailableChannelName({
-					client,
-					workspaceId: binding.workspaceId,
-					label,
-					sessionKey,
-					agentId: binding.agentId,
-					ownChannelId: binding.channelId
-				});
-				try {
-					const renamed = await client.updateChannel(binding.channelId, patch);
-					assertChannelPatch(renamed, patch);
-					return renamed;
-				} catch (error) {
-					if (!isClickClackChannelNameConflict(error) || attempt === CHANNEL_NAME_MUTATION_ATTEMPTS - 1) throw error;
-				}
-			}
-			throw new Error("ClickClack discussion channel name retries were exhausted");
-		});
-		else {
-			updated = await client.updateChannel(binding.channelId, patch);
-			assertChannelPatch(updated, patch);
-		}
-		if (deleted) {
-			this.#revokeAndDeleteBinding(sessionKey, binding);
-			return;
-		}
-		this.#store.set(sessionKey, {
-			...binding,
-			archived,
-			externalUrl,
-			label,
-			section,
-			displayTitle: "display_title" in updated ? updated.display_title : void 0
-		});
-	}
-	async #reconcilePendingOpen(pending, options = {}) {
-		const currentBinding = this.#store.get(pending.sessionKey);
-		if (currentBinding?.externalRef === pending.externalRef) {
-			this.#finalizePendingBinding(pending.sessionKey, currentBinding);
-			return;
-		}
-		const cfg = this.#currentConfig();
-		const account = listClickClackAccountIds(cfg).map((accountId) => resolveClickClackAccount({
-			cfg,
-			accountId
-		})).find((candidate) => candidate.configured && normalizedServerBaseUrl(candidate) === pending.serverBaseUrl && discussionCredentialFingerprint(candidate.token) === pending.credentialFingerprint);
-		if (!account) return;
-		const client = this.#clientFactory(account);
-		const entry = this.#runtime.agent.session.getSessionEntry({
-			sessionKey: pending.sessionKey,
-			readConsistency: "latest"
-		});
-		const activeAccounts = discussionAccounts(cfg);
-		const retryAccount = activeAccounts.length === 1 ? activeAccounts[0] : void 0;
-		if (options.allowRetry !== false && entry?.sessionId === pending.sessionId && retryAccount && normalizedServerBaseUrl(retryAccount) === pending.serverBaseUrl && discussionCredentialFingerprint(retryAccount.token) === pending.credentialFingerprint) {
-			if ((await this.#clientFactory(retryAccount).workspaces()).find((candidate) => candidate.id === retryAccount.discussions.workspace || candidate.slug === retryAccount.discussions.workspace || candidate.name === retryAccount.discussions.workspace)?.id === pending.workspaceId) {
-				await this.open(pending.sessionKey);
-				return;
-			}
-		}
-		const channels = await client.channels(pending.workspaceId);
-		assertManagedChannelListContract(channels);
-		const channel = channels.find((candidate) => candidate.external_managed === true && candidate.external_ref === pending.externalRef);
-		if (channel) {
-			markClickClackDiscussionChannelIdentityRevoked({
-				runtime: this.#runtime,
-				accountId: pending.accountId,
-				serverBaseUrl: pending.serverBaseUrl,
-				channelId: channel.id
-			});
-			assertChannelPatch(await client.updateChannel(channel.id, { archived: true }), { archived: true });
-		}
-		clearDiscussionBindingGeneration({
-			runtime: this.#runtime,
-			sessionKey: pending.sessionKey,
-			expectedGeneration: pending.generation
-		});
-	}
-	async #releaseStaleBinding(sessionKey, binding) {
-		clearDiscussionBindingGeneration({
-			runtime: this.#runtime,
-			sessionKey
-		});
-		const boundAccount = resolveClickClackAccount({
-			cfg: this.#currentConfig(),
-			accountId: binding.accountId
-		});
-		if (!boundAccount.configured || binding.serverBaseUrl !== normalizedServerBaseUrl(boundAccount) || !binding.credentialFingerprint || binding.credentialFingerprint !== discussionCredentialFingerprint(boundAccount.token)) {
-			this.#revokeAndDeleteBinding(sessionKey, binding);
-			return;
-		}
-		assertChannelPatch(await this.#clientFactory(boundAccount).updateChannel(binding.channelId, { archived: true }), { archived: true });
-		this.#revokeAndDeleteBinding(sessionKey, binding);
-	}
-	async #archiveAndDeleteBinding(sessionKey, binding, account) {
-		clearDiscussionBindingGeneration({
-			runtime: this.#runtime,
-			sessionKey
-		});
-		assertChannelPatch(await this.#clientFactory(account).updateChannel(binding.channelId, { archived: true }), { archived: true });
-		this.#revokeAndDeleteBinding(sessionKey, binding);
-	}
-	#revokeAndDeleteBinding(sessionKey, binding) {
-		markClickClackDiscussionChannelRevoked(this.#runtime, binding);
-		this.#store.delete(sessionKey);
-	}
-	#finalizePendingBinding(sessionKey, binding) {
-		const pending = listPendingDiscussionOpens(this.#runtime).find((candidate) => candidate.sessionKey === sessionKey && candidate.externalRef === binding.externalRef);
-		if (pending) {
-			clearClickClackDiscussionChannelRevoked({
-				runtime: this.#runtime,
-				serverBaseUrl: binding.serverBaseUrl,
-				channelId: binding.channelId
-			});
-			clearDiscussionBindingGeneration({
-				runtime: this.#runtime,
-				sessionKey,
-				expectedGeneration: pending.generation
-			});
-		}
-	}
-	async #resolveBindingForUse(binding) {
-		const resolved = resolveDiscussionBindingAccount(this.#currentConfig(), binding);
-		if (resolved.state !== "active") return resolved;
-		return (await this.#clientFactory(resolved.account).workspaces()).find((candidate) => candidate.id === resolved.account.discussions.workspace || candidate.slug === resolved.account.discussions.workspace || candidate.name === resolved.account.discussions.workspace)?.id === binding.workspaceId ? resolved : { state: "retargeted" };
-	}
-	#currentConfig() {
-		return this.#runtime.config.current();
-	}
-	#ensureTimer() {
-		const hasPendingOpens = listPendingDiscussionOpens(this.#runtime).length > 0;
-		const needsBindingPoll = this.#unsubscribeSessionsChanged === void 0 && this.#store.entries().length > 0;
-		if (this.#closed || !hasPendingOpens && !needsBindingPoll) {
-			if (this.#timer) {
-				clearInterval(this.#timer);
-				this.#timer = void 0;
-			}
-			return;
-		}
-		if (!this.#timersEnabled || this.#timer) return;
-		this.#timer = setInterval(() => {
-			this.reconcileAll().catch((error) => {
-				this.#logger().warn(`discussion reconcile pass failed: ${String(error)}`);
-			}).finally(() => {
-				this.#ensureTimer();
-			});
-		}, RECONCILE_INTERVAL_MS);
-		this.#timer.unref?.();
-	}
-	#listReconcileSessionKeys() {
-		return /* @__PURE__ */ new Set([...this.#store.entries().map(({ sessionKey }) => sessionKey), ...listPendingDiscussionOpens(this.#runtime).map(({ sessionKey }) => sessionKey)]);
-	}
-	#logger() {
-		return this.#runtime.logging.getChildLogger({
-			plugin: "clickclack",
-			feature: "discussions"
-		});
-	}
-	async #withSessionLock(sessionKey, run) {
-		const current = (this.#sessionLocks.get(sessionKey) ?? Promise.resolve()).catch(() => void 0).then(run);
-		this.#sessionLocks.set(sessionKey, current);
-		try {
-			return await current;
-		} finally {
-			if (this.#sessionLocks.get(sessionKey) === current) this.#sessionLocks.delete(sessionKey);
-		}
-	}
-	async #withChannelMutationLock(run) {
-		const current = this.#channelMutationLock.catch(() => void 0).then(run);
-		this.#channelMutationLock = current;
-		return await current;
-	}
-};
-//#endregion
-//#region extensions/clickclack/src/discussions/tool-policy.ts
-const TARGETED_SESSION_TOOLS = /* @__PURE__ */ new Set([
-	"sessions_history",
-	"sessions_send",
-	"session_status"
-]);
-function blockedResult() {
-	return {
-		block: true,
-		blockReason: `ClickClack discussion sessions may use ${[...TARGETED_SESSION_TOOLS].join(", ")} only with their attached main session.`
-	};
-}
-function isClickClackDiscussionSessionTarget(params) {
-	const matched = getClickClackDiscussionBindingStore(params.runtime).getByDiscussionSession(params.requesterSessionKey);
-	if (matched && matched.sessionKey === params.targetSessionKey && !isClickClackDiscussionChannelRevoked({
-		runtime: params.runtime,
-		serverBaseUrl: matched.binding.serverBaseUrl,
-		channelId: matched.binding.channelId
-	}) && !matched.binding.archived && bindingMatchesActiveSessionIncarnation(params.runtime, matched.sessionKey, matched.binding) && resolveDiscussionBindingAccount(params.runtime.config.current(), matched.binding).state === "active") return matched;
-}
-/** Restricts a discussion side session's session tools to its attached main session. */
-function enforceClickClackDiscussionToolTarget(params) {
-	const callerSessionKey = params.context.sessionKey;
-	if (!callerSessionKey) return;
-	const { toolName } = params.event;
-	if (toolName !== "session_status" && !toolName.startsWith("sessions_")) return;
-	const matched = getClickClackDiscussionBindingStore(params.runtime).getByDiscussionSession(callerSessionKey);
-	if (!matched) return isDiscussionSessionKey(callerSessionKey) ? blockedResult() : void 0;
-	const targetsMain = Boolean(isClickClackDiscussionSessionTarget({
-		runtime: params.runtime,
-		requesterSessionKey: callerSessionKey,
-		targetSessionKey: matched.sessionKey
-	})) && TARGETED_SESSION_TOOLS.has(toolName) && params.event.params.sessionKey === matched.sessionKey;
-	const usesAlternateSendTarget = toolName === "sessions_send" && (params.event.params.label !== void 0 || params.event.params.agentId !== void 0);
-	const mutatesStatus = toolName === "session_status" && params.event.params.model !== void 0;
-	const selectsHistoryIncarnation = toolName === "sessions_history" && params.event.params.sessionId !== void 0;
-	if (targetsMain && !usesAlternateSendTarget && !mutatesStatus && !selectsHistoryIncarnation) return;
-	return blockedResult();
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/tool.ts
-const DEFAULT_MESSAGE_LIMIT = 30;
-const MAX_MESSAGE_LIMIT = 200;
-function createClickClackDiscussionTool(params) {
-	return {
-		name: "discussion",
-		label: "Discussion",
-		description: "Read the latest messages from the ClickClack discussion bound to this session.",
-		parameters: {
-			type: "object",
-			properties: { limit: {
-				type: "integer",
-				minimum: 1,
-				maximum: MAX_MESSAGE_LIMIT,
-				description: `Maximum messages to return (default ${DEFAULT_MESSAGE_LIMIT}).`
-			} },
-			additionalProperties: false
-		},
-		async execute(_toolCallId, input) {
-			if (!params.sessionKey) return textResult("No discussion is bound to this session.", { bound: false });
-			const requested = typeof input === "object" && input !== null && "limit" in input ? Number(input.limit) : DEFAULT_MESSAGE_LIMIT;
-			const limit = Number.isInteger(requested) ? Math.max(1, Math.min(MAX_MESSAGE_LIMIT, requested)) : DEFAULT_MESSAGE_LIMIT;
-			const result = await params.service.readLatestMessages(params.sessionKey, limit);
-			return textResult(result.text, {
-				bound: Boolean(result.binding),
-				limit,
-				...result.binding ? { channelId: result.binding.channelId } : {}
-			});
-		}
-	};
-}
-//#endregion
-//#region extensions/clickclack/src/discussions/register.ts
-function registerClickClackDiscussions(api) {
-	if (api.registrationMode === "tool-discovery") {
-		api.registerTool(() => null, { name: "discussion" });
-		return;
-	}
-	const service = new ClickClackDiscussionService(api.runtime);
-	api.registerService({
-		id: "clickclack-discussion-session-events",
-		start: ({ gatewayEvents }) => {
-			service.bindGatewayEvents(gatewayEvents);
-		},
-		stop: () => {
-			service.cleanup();
-		}
-	});
-	api.registerTool((context) => createClickClackDiscussionTool({
-		service,
-		sessionKey: context.sessionKey
-	}));
-	api.on("before_tool_call", (event, context) => enforceClickClackDiscussionToolTarget({
-		runtime: api.runtime,
-		event,
-		context
-	}));
-	const unregisterSessionAccess = createSessionVisibilityChecker.registerScopedAccessProvider(({ requesterSessionKey, targetSessionKey }) => {
-		const target = isClickClackDiscussionSessionTarget({
-			runtime: api.runtime,
-			requesterSessionKey,
-			targetSessionKey
-		});
-		return target ? { expectedSessionId: target.binding.sessionId } : void 0;
-	});
-	registerSessionDiscussionProvider(service.provider);
-	api.lifecycle.registerRuntimeLifecycle({
-		id: "clickclack-discussions",
-		description: "Stops the lifecycle reconciler for managed ClickClack discussions.",
-		cleanup: () => {
-			unregisterSessionAccess();
-			service.cleanup();
-		}
-	});
-}
-//#endregion
-export { registerClickClackDiscussions as t };