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

package/dist/{channel-Ds6d_3nx.js → channel-CEYthZ9N.js}

@@ -1,158 +1,18 @@
-import { createAccountListHelpers, hasConfiguredAccountValue } from "openclaw/plugin-sdk/account-helpers";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
-import { resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
-import { resolveDefaultSecretProviderAlias } from "openclaw/plugin-sdk/provider-auth";
-import { buildSecretInputSchema, normalizeResolvedSecretInputString, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { a as createClickClackClient, c as CLICKCLACK_CHANNEL_ID, d as DEFAULT_ACCOUNT_ID, i as resolveWorkspaceId, l as clickClackConfigAdapter, m as resolveClickClackAccount, n as clickClackSetupAdapter, o as normalizeClickClackCorrelationId, r as resolveChannelId, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-CNjp76Xx.js";
+import { 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 { getChatChannelMeta } from "openclaw/plugin-sdk/channel-plugin-common";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
-import { z } from "zod";
 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 { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
-import { WebSocket } from "ws";
+import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
+import { createChannelInboundEnvelopeBuilder } from "openclaw/plugin-sdk/channel-inbound";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { createHash } from "node:crypto";
 import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
-//#region extensions/clickclack/src/accounts.ts
-/**
-* Resolves ClickClack account configuration from root channel config, named
-* account overrides, and secret-provider references.
-*/
-const DEFAULT_RECONNECT_MS = 1500;
-const MIN_RECONNECT_MS = 100;
-const MAX_RECONNECT_MS = 6e4;
-const { listAccountIds: listClickClackAccountIds, resolveDefaultAccountId: resolveDefaultClickClackAccountId } = createAccountListHelpers("clickclack", {
-	normalizeAccountId,
-	hasImplicitDefaultAccount: (cfg) => {
-		const channel = cfg.channels?.clickclack;
-		return Boolean(channel?.baseUrl?.trim() && hasConfiguredAccountValue(channel.token) && channel.workspace?.trim());
-	}
-});
-function resolveMergedClickClackAccountConfig(cfg, accountId) {
-	return resolveMergedAccountConfig({
-		channelConfig: cfg.channels?.clickclack,
-		accounts: cfg.channels?.clickclack?.accounts,
-		accountId,
-		omitKeys: ["defaultAccount"],
-		normalizeAccountId
-	});
-}
-function resolveClickClackToken(params) {
-	const resolved = resolveSecretInputString({
-		value: params.value,
-		path: params.accountId === DEFAULT_ACCOUNT_ID ? "channels.clickclack.token" : `channels.clickclack.accounts.${params.accountId}.token`,
-		defaults: params.cfg.secrets?.defaults,
-		mode: "inspect"
-	});
-	if (resolved.status !== "available") {
-		if (resolved.status === "configured_unavailable" && resolved.ref.source === "env") {
-			const providerConfig = params.cfg.secrets?.providers?.[resolved.ref.provider];
-			if (providerConfig) {
-				if (providerConfig.source !== "env") throw new Error(`Secret provider "${resolved.ref.provider}" has source "${providerConfig.source}" but ref requests "env".`);
-				if (providerConfig.allowlist && !providerConfig.allowlist.includes(resolved.ref.id)) throw new Error(`Environment variable "${resolved.ref.id}" is not allowlisted in secrets.providers.${resolved.ref.provider}.allowlist.`);
-			} else if (resolved.ref.provider !== resolveDefaultSecretProviderAlias({ secrets: params.cfg.secrets }, "env")) throw new Error(`Secret provider "${resolved.ref.provider}" is not configured (ref: env:${resolved.ref.provider}:${resolved.ref.id}).`);
-			return normalizeSecretInputString((params.env ?? process.env)[resolved.ref.id]) ?? "";
-		}
-		return "";
-	}
-	return normalizeResolvedSecretInputString({
-		value: resolved.value,
-		path: "channels.clickclack.token"
-	}) ?? "";
-}
-/**
-* Builds the normalized account snapshot used by gateway, outbound delivery,
-* status reporting, and channel routing.
-*/
-function resolveClickClackAccount(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const merged = resolveMergedClickClackAccountConfig(params.cfg, accountId);
-	const enabled = params.cfg.channels?.clickclack?.enabled !== false && merged.enabled !== false;
-	const baseUrl = merged.baseUrl?.trim().replace(/\/$/, "") ?? "";
-	const token = resolveClickClackToken({
-		cfg: params.cfg,
-		value: merged.token,
-		accountId,
-		env: params.env
-	});
-	const workspace = merged.workspace?.trim() ?? "";
-	return {
-		accountId,
-		enabled,
-		configured: Boolean(baseUrl && token && workspace),
-		name: normalizeOptionalString(merged.name),
-		baseUrl,
-		token,
-		workspace,
-		botUserId: normalizeOptionalString(merged.botUserId),
-		agentId: normalizeOptionalString(merged.agentId),
-		replyMode: merged.replyMode === "model" ? "model" : "agent",
-		model: normalizeOptionalString(merged.model),
-		systemPrompt: normalizeOptionalString(merged.systemPrompt),
-		timeoutSeconds: merged.timeoutSeconds,
-		toolsAllow: merged.toolsAllow,
-		defaultTo: merged.defaultTo?.trim() || "channel:general",
-		allowFrom: merged.allowFrom ?? ["*"],
-		reconnectMs: resolveIntegerOption(merged.reconnectMs, DEFAULT_RECONNECT_MS, {
-			min: MIN_RECONNECT_MS,
-			max: MAX_RECONNECT_MS
-		}),
-		agentActivity: merged.agentActivity === true,
-		config: {
-			...merged,
-			allowFrom: merged.allowFrom ?? ["*"]
-		}
-	};
-}
-/**
-* Returns all enabled accounts, including the implicit default account when
-* legacy top-level ClickClack config is present.
-*/
-function listEnabledClickClackAccounts(cfg) {
-	return listClickClackAccountIds(cfg).map((accountId) => resolveClickClackAccount({
-		cfg,
-		accountId
-	})).filter((account) => account.enabled);
-}
-//#endregion
-//#region extensions/clickclack/src/config-schema.ts
-/**
-* Zod-backed config schema for ClickClack channel accounts.
-*/
-const ClickClackAccountConfigSchema = z.object({
-	name: z.string().optional(),
-	enabled: z.boolean().optional(),
-	baseUrl: z.string().url().optional(),
-	token: buildSecretInputSchema().optional(),
-	workspace: z.string().optional(),
-	botUserId: z.string().optional(),
-	agentId: z.string().optional(),
-	replyMode: z.enum(["agent", "model"]).optional(),
-	model: z.string().optional(),
-	systemPrompt: z.string().optional(),
-	timeoutSeconds: z.number().int().min(1).max(3600).optional(),
-	toolsAllow: z.array(z.string()).optional(),
-	defaultTo: z.string().optional(),
-	allowFrom: z.array(z.string()).optional(),
-	reconnectMs: z.number().int().min(100).max(6e4).optional(),
-	agentActivity: z.boolean().optional()
-}).strict();
-/**
-* Config schema exported to core so `openclaw doctor` and config validation
-* understand both default and named ClickClack accounts.
-*/
-const clickClackConfigSchema = buildChannelConfigSchema(ClickClackAccountConfigSchema.extend({
-	accounts: z.record(z.string(), ClickClackAccountConfigSchema.partial()).optional(),
-	defaultAccount: z.string().optional()
-}).strict());
-//#endregion
 //#region extensions/clickclack/src/runtime.ts
 /**
 * Runtime store for host-provided OpenClaw services used by the ClickClack
@@ -215,223 +75,62 @@ async function resolveClickClackInboundAccess(params) {
 	};
 }
 //#endregion
-//#region extensions/clickclack/src/http-client.ts
-/**
-* Thin ClickClack REST/websocket client used by gateway, resolver, and outbound
-* delivery code.
-*/
-/**
-* Serializes optional provenance into the wire fields. Unknown JSON fields
-* are ignored by servers without the provenance columns, so these are safe
-* to send unconditionally when present.
-*/
-function provenanceFields(provenance) {
-	const fields = {};
-	if (provenance?.model?.trim()) fields.author_model = provenance.model.trim();
-	if (provenance?.thinking?.trim()) fields.author_thinking = provenance.thinking.trim();
-	if (provenance?.runtime?.trim()) fields.author_runtime = provenance.runtime.trim();
-	return fields;
+//#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("");
 }
-const CLICKCLACK_ERROR_BODY_LIMIT_BYTES = 8 * 1024;
-const CLICKCLACK_CORRELATION_ID_MAX_LENGTH = 128;
-const CLICKCLACK_CORRELATION_ID_PATTERN = /^[A-Za-z0-9._:-]+$/u;
-const CLICKCLACK_CORRELATION_ID_HEADER = "X-Correlation-ID";
-const CLICKCLACK_INBOUND_JSON_LIMIT_BYTES = 16 * 1024 * 1024;
-var ClickClackHttpError = class extends Error {
-	constructor(status, detail, headers) {
-		super(`ClickClack ${status}: ${detail}`);
-		this.status = status;
-		this.headers = headers;
-	}
-};
-/** Accepts the same bounded request-correlation shape as the ClickClack API. */
-function normalizeClickClackCorrelationId(value) {
-	if (typeof value !== "string") return;
-	const normalized = value.trim();
-	if (!normalized || normalized.length > CLICKCLACK_CORRELATION_ID_MAX_LENGTH || !CLICKCLACK_CORRELATION_ID_PATTERN.test(normalized)) return;
-	return normalized;
+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]" : "";
 }
-/**
-* Creates a typed client for the ClickClack API using bearer-token auth.
-*/
-function createClickClackClient(options) {
-	const baseUrl = options.baseUrl.replace(/\/$/, "");
-	const fetcher = options.fetch ?? fetch;
-	const correlationId = normalizeClickClackCorrelationId(options.correlationId);
-	const headers = {
-		Authorization: `Bearer ${options.token}`,
-		Accept: "application/json"
-	};
-	async function request(path, init = {}) {
-		const requestHeaders = new Headers(init.headers);
-		for (const [key, value] of Object.entries(headers)) requestHeaders.set(key, value);
-		if (correlationId) requestHeaders.set(CLICKCLACK_CORRELATION_ID_HEADER, correlationId);
-		if (init.body && !(init.body instanceof FormData)) requestHeaders.set("Content-Type", "application/json");
-		const response = await fetcher(`${baseUrl}${path}`, {
-			...init,
-			headers: requestHeaders
-		});
-		if (!response.ok) {
-			const detail = await readResponseTextLimited(response, CLICKCLACK_ERROR_BODY_LIMIT_BYTES);
-			throw new ClickClackHttpError(response.status, detail, new Headers(response.headers));
+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;
 		}
-		return await readProviderJsonResponse(response, "ClickClack response", { maxBytes: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES });
-	}
-	async function fetchEventPage(workspaceId, pageOptions = {}) {
-		const query = new URLSearchParams({ workspace_id: workspaceId });
-		if (pageOptions.afterCursor) query.set("after_cursor", pageOptions.afterCursor);
-		if (pageOptions.limit !== void 0) query.set("limit", String(pageOptions.limit));
-		if (pageOptions.includeTail) query.set("include_tail", "true");
-		const data = await request(`/api/realtime/events?${query.toString()}`);
-		return {
-			events: data.events,
-			...typeof data.tail_cursor === "string" ? { tailCursor: data.tail_cursor } : {}
-		};
+		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)
+		});
 	}
-	return {
-		me: async () => {
-			return (await request("/api/me")).user;
-		},
-		workspaces: async () => {
-			return (await request("/api/workspaces")).workspaces;
-		},
-		channels: async (workspaceId) => {
-			return (await request(`/api/workspaces/${encodeURIComponent(workspaceId)}/channels`)).channels;
-		},
-		channelMessages: async (channelId, afterSeq, limit = 20) => {
-			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages?after_seq=${afterSeq}&limit=${limit}`)).messages;
-		},
-		directMessages: async (conversationId, afterSeq, limit = 20) => {
-			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages?after_seq=${afterSeq}&limit=${limit}`)).messages;
-		},
-		thread: async (messageId) => await request(`/api/messages/${encodeURIComponent(messageId)}/thread`),
-		message: async (messageId) => {
-			return (await request(`/api/messages/${encodeURIComponent(messageId)}`)).message;
-		},
-		findMessageByNonce: async (params) => {
-			const query = new URLSearchParams({
-				workspace_id: params.workspaceId,
-				nonce: params.nonce
-			});
-			try {
-				return (await request(`/api/messages/by-nonce?${query.toString()}`)).message;
-			} catch (error) {
-				if (error instanceof ClickClackHttpError && error.status === 404) {
-					if (error.headers.get("X-ClickClack-Message-Nonce") === "supported") return;
-					throw new Error("ClickClack server does not support durable message nonce lookup", { cause: error });
-				}
-				throw error;
-			}
-		},
-		createChannelMessage: async (channelId, body, opts) => {
-			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages`, {
-				method: "POST",
-				body: JSON.stringify({
-					body,
-					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
-					...opts?.nonce ? { nonce: opts.nonce } : {},
-					...provenanceFields(opts?.provenance)
-				})
-			})).message;
-		},
-		createThreadReply: async (messageId, body, opts) => {
-			return (await request(`/api/messages/${encodeURIComponent(messageId)}/thread/replies`, {
-				method: "POST",
-				body: JSON.stringify({
-					body,
-					...opts?.nonce ? { nonce: opts.nonce } : {},
-					...provenanceFields(opts?.provenance)
-				})
-			})).message;
-		},
-		createDirectConversation: async (workspaceId, memberIds) => {
-			return (await request("/api/dms", {
-				method: "POST",
-				body: JSON.stringify({
-					workspace_id: workspaceId,
-					member_ids: memberIds
-				})
-			})).conversation;
-		},
-		createUpload: async (params) => {
-			const form = new FormData();
-			const bytes = new Uint8Array(params.buffer);
-			form.append("file", new Blob([bytes], { type: params.contentType }), params.filename);
-			const query = new URLSearchParams({ workspace_id: params.workspaceId });
-			if (params.nonce) query.set("nonce", params.nonce);
-			return (await request(`/api/uploads?${query.toString()}`, {
-				method: "POST",
-				body: form
-			})).upload;
-		},
-		findUploadByNonce: async (params) => {
-			const query = new URLSearchParams({
-				workspace_id: params.workspaceId,
-				nonce: params.nonce
-			});
-			try {
-				return (await request(`/api/uploads/by-nonce?${query.toString()}`)).upload;
-			} catch (error) {
-				if (error instanceof ClickClackHttpError && error.status === 404) {
-					if (error.headers.get("X-ClickClack-Upload-Nonce") === "supported") return;
-					throw new Error("ClickClack server does not support durable upload nonce lookup", { cause: error });
-				}
-				throw error;
-			}
-		},
-		attachUpload: async (messageId, uploadId) => {
-			await request(`/api/messages/${encodeURIComponent(messageId)}/attachments`, {
-				method: "POST",
-				body: JSON.stringify({ upload_id: uploadId })
-			});
-		},
-		/**
-		* POSTs a durable agent activity row (agent_commentary / agent_tool)
-		* through the normal message create path. Requires a bot token carrying
-		* the agent_activity:write scope on the ClickClack side.
-		*/
-		createActivityMessage: async (params) => {
-			if (!params.channelId && !params.conversationId) throw new Error("createActivityMessage requires a channelId or conversationId");
-			return (await request(params.channelId ? `/api/channels/${encodeURIComponent(params.channelId)}/messages` : `/api/dms/${encodeURIComponent(params.conversationId ?? "")}/messages`, {
-				method: "POST",
-				body: JSON.stringify({
-					body: params.body,
-					kind: params.kind,
-					turn_id: params.turnId,
-					...provenanceFields(params.provenance)
-				})
-			})).message;
-		},
-		/** PATCHes the body of an existing message (activity row coalescing). */
-		updateMessageBody: async (messageId, body) => {
-			return (await request(`/api/messages/${encodeURIComponent(messageId)}`, {
-				method: "PATCH",
-				body: JSON.stringify({ body })
-			})).message;
-		},
-		createDirectMessage: async (conversationId, body, opts) => {
-			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages`, {
-				method: "POST",
-				body: JSON.stringify({
-					body,
-					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
-					...opts?.nonce ? { nonce: opts.nonce } : {}
-				})
-			})).message;
-		},
-		events: async (workspaceId, afterCursor) => (await fetchEventPage(workspaceId, { afterCursor })).events,
-		eventPage: fetchEventPage,
-		websocket: (workspaceId, afterCursor) => {
-			const url = new URL(`${baseUrl}/api/realtime/ws`);
-			url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-			url.searchParams.set("workspace_id", workspaceId);
-			if (afterCursor) url.searchParams.set("after_cursor", afterCursor);
-			return new WebSocket(url, {
-				headers: { Authorization: `Bearer ${options.token}` },
-				maxPayload: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES
-			});
+	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
@@ -629,27 +328,6 @@ function createClickClackActivityPublisher(params) {
 	};
 }
 //#endregion
-//#region extensions/clickclack/src/resolve.ts
-/**
-* Resolves a workspace slug/name/id from config to a ClickClack workspace id.
-*/
-async function resolveWorkspaceId(client, workspace) {
-	if (workspace.startsWith("wsp_")) return workspace;
-	const found = (await client.workspaces()).find((candidate) => candidate.id === workspace || candidate.slug === workspace || candidate.name === workspace);
-	if (!found) throw new Error(`ClickClack workspace not found: ${workspace}`);
-	return found.id;
-}
-/**
-* Resolves a channel name/id from config or target input to a ClickClack
-* channel id.
-*/
-async function resolveChannelId(client, workspaceId, channel) {
-	if (channel.startsWith("chn_")) return channel;
-	const found = (await client.channels(workspaceId)).find((candidate) => candidate.id === channel || candidate.name === channel);
-	if (!found) throw new Error(`ClickClack channel not found: ${channel}`);
-	return found.id;
-}
-//#endregion
 //#region extensions/clickclack/src/target.ts
 /**
 * Parses `channel:name`, `thread:msg_id`, `dm:usr_id`, or a bare channel name.
@@ -1063,6 +741,8 @@ async function handleClickClackInbound(params) {
 		message
 	});
 	if (!access.shouldDispatch) return;
+	const conversationId = message.channel_id || message.direct_conversation_id;
+	if (!conversationId) return;
 	const isDirect = Boolean(message.direct_conversation_id);
 	const target = buildClickClackTarget(isDirect ? {
 		chatType: "direct",
@@ -1108,46 +788,60 @@ async function handleClickClackInbound(params) {
 		}
 	});
 	const senderName = message.author?.display_name || message.author_id;
-	const previousTimestamp = runtime.channel.session.readSessionUpdatedAt({
-		storePath: runtime.channel.session.resolveStorePath(params.config.session?.store, { agentId: route.agentId }),
-		sessionKey: route.sessionKey
-	});
-	const body = runtime.channel.reply.formatAgentEnvelope({
+	const body = createChannelInboundEnvelopeBuilder({
+		cfg: params.config,
+		route
+	})({
 		channel: "ClickClack",
 		from: senderName,
 		timestamp: new Date(message.created_at),
-		previousTimestamp,
-		envelope: runtime.channel.reply.resolveEnvelopeFormatOptions(params.config),
 		body: message.body
 	});
-	const storePath = runtime.channel.session.resolveStorePath(params.config.session?.store, { agentId: route.agentId });
-	const ctxPayload = runtime.channel.reply.finalizeInboundContext({
-		Body: body,
-		BodyForAgent: message.body,
-		RawBody: message.body,
-		CommandBody: message.body,
-		From: target,
-		To: target,
-		SessionKey: route.sessionKey,
-		AccountId: route.accountId ?? params.account.accountId,
-		ChatType: isDirect ? "direct" : "group",
-		WasMentioned: isDirect ? void 0 : true,
-		ConversationLabel: isDirect ? senderName : message.channel_id,
-		GroupChannel: message.channel_id,
-		NativeChannelId: message.channel_id || message.direct_conversation_id,
-		MessageThreadId: message.parent_message_id ? message.thread_root_id : void 0,
-		ThreadParentId: message.parent_message_id ? message.thread_root_id : void 0,
-		SenderName: senderName,
-		SenderId: message.author_id,
-		Provider: CHANNEL_ID$1,
-		Surface: CHANNEL_ID$1,
-		MessageSid: message.id,
-		MessageSidFull: message.id,
-		ReplyToId: message.id,
-		Timestamp: message.created_at,
-		OriginatingChannel: CHANNEL_ID$1,
-		OriginatingTo: target,
-		CommandAuthorized: access.commandAuthorized
+	const ctxPayload = runtime.channel.inbound.buildContext({
+		channel: CHANNEL_ID$1,
+		accountId: route.accountId ?? params.account.accountId,
+		messageId: message.id,
+		messageIdFull: message.id,
+		timestamp: new Date(message.created_at).getTime(),
+		from: target,
+		sender: {
+			id: message.author_id,
+			name: senderName
+		},
+		conversation: {
+			kind: isDirect ? "direct" : "group",
+			id: conversationId,
+			label: isDirect ? senderName : message.channel_id,
+			threadId: message.parent_message_id ? message.thread_root_id : void 0,
+			nativeChannelId: conversationId
+		},
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			accountId: route.accountId,
+			routeSessionKey: route.sessionKey
+		},
+		reply: {
+			to: target,
+			originatingTo: target,
+			replyToId: message.id,
+			messageThreadId: message.parent_message_id ? message.thread_root_id : void 0,
+			threadParentId: message.parent_message_id ? message.thread_root_id : void 0
+		},
+		message: {
+			body,
+			bodyForAgent: message.body,
+			rawBody: message.body,
+			commandBody: message.body
+		},
+		access: {
+			commands: { authorized: access.commandAuthorized },
+			mentions: {
+				canDetectMention: !isDirect,
+				wasMentioned: !isDirect
+			}
+		},
+		extra: { GroupChannel: message.channel_id }
 	});
 	const runId = resolveClickClackAgentRunId(message.id);
 	const activityReplyOptions = activity ? {
@@ -1163,16 +857,16 @@ async function handleClickClackInbound(params) {
 		suppressDefaultToolProgressMessages: true,
 		allowProgressCallbacksWhenSourceDeliverySuppressed: true
 	} : void 0;
-	const dispatchPromise = runtime.channel.inbound.dispatchReply({
+	const dispatchPromise = runtime.channel.inbound.dispatch({
 		cfg: params.config,
 		channel: CHANNEL_ID$1,
 		accountId: params.account.accountId,
-		agentId: route.agentId,
-		routeSessionKey: route.sessionKey,
-		storePath,
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			sessionKey: route.sessionKey
+		},
 		ctxPayload,
-		recordInboundSession: runtime.channel.session.recordInboundSession,
-		dispatchReplyWithBufferedBlockDispatcher: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		toolsAllow: params.account.toolsAllow,
 		replyOptions: runId || activityReplyOptions ? {
 			...runId ? { runId } : {},
@@ -1322,6 +1016,18 @@ async function startClickClackGatewayAccount(ctx) {
 		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,
@@ -1343,20 +1049,15 @@ async function startClickClackGatewayAccount(ctx) {
 				workspaceId,
 				afterCursor,
 				abortSignal: ctx.abortSignal,
-				onEvent: async (event) => {
-					await processEvent({
-						account,
-						config: ctx.cfg,
-						client,
-						event,
-						botUserId: account.botUserId
-					});
-				}
+				onEvent: processIncomingEvent
 			});
 			if (ctx.abortSignal.aborted) break;
 			const socket = client.websocket(workspaceId, afterCursor);
-			await new Promise((resolve, reject) => {
+			await new Promise((resolve) => {
 				let settled = false;
+				let closing = false;
+				let loggedMessageFailure = false;
+				let messageQueue = Promise.resolve();
 				let removeAbortListener;
 				const finishSocketCycle = () => {
 					if (settled) return;
@@ -1365,6 +1066,20 @@ async function startClickClackGatewayAccount(ctx) {
 					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();
@@ -1372,36 +1087,38 @@ async function startClickClackGatewayAccount(ctx) {
 				ctx.abortSignal.addEventListener("abort", abort, { once: true });
 				removeAbortListener = () => ctx.abortSignal.removeEventListener("abort", abort);
 				socket.on("message", (data) => {
-					(async () => {
+					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;
-						await processEvent({
-							account,
-							config: ctx.cfg,
-							client,
-							event,
-							botUserId: account.botUserId ?? ""
-						});
-					})().catch((e) => reject(e instanceof Error ? e : new Error(`ClickClack ws message failed: ${formatErrorMessage(e)}`, { cause: e })));
+					});
+					messageQueue.catch(reconnectAfterMessageFailure);
+				});
+				socket.on("close", () => {
+					closing = true;
+					finishAfterQueuedMessages();
 				});
-				socket.on("close", finishSocketCycle);
 				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)}`);
-					finishSocketCycle();
+					closing = true;
 					socket.close();
 				});
 			});
-			if (!ctx.abortSignal.aborted) await new Promise((resolve) => {
-				setTimeout(resolve, account.reconnectMs);
-			});
+			if (!ctx.abortSignal.aborted) try {
+				await sleepWithAbort(account.reconnectMs, ctx.abortSignal);
+			} catch (error) {
+				if (!ctx.abortSignal.aborted) throw error;
+			}
 		}
 	} finally {
 		ctx.setStatus({
@@ -1416,8 +1133,7 @@ async function startClickClackGatewayAccount(ctx) {
 * ClickClack channel plugin definition: target parsing, account config, status,
 * gateway startup, and outbound delivery wiring.
 */
-const CHANNEL_ID = "clickclack";
-const meta = { ...getChatChannelMeta(CHANNEL_ID) };
+const CHANNEL_ID = CLICKCLACK_CHANNEL_ID;
 const clickClackMessageAdapter = defineChannelMessageAdapter({
 	id: CHANNEL_ID,
 	durableFinal: {
@@ -1502,7 +1218,7 @@ const clickClackMessageAdapter = defineChannelMessageAdapter({
 const clickClackPlugin = createChatChannelPlugin({
 	base: {
 		id: CHANNEL_ID,
-		meta,
+		meta: clickClackMeta,
 		capabilities: {
 			chatTypes: ["direct", "group"],
 			threads: true,
@@ -1510,22 +1226,12 @@ const clickClackPlugin = createChatChannelPlugin({
 		},
 		reload: { configPrefixes: ["channels.clickclack"] },
 		configSchema: clickClackConfigSchema,
-		config: {
-			listAccountIds: (cfg) => listClickClackAccountIds(cfg),
-			resolveAccount: (cfg, accountId) => resolveClickClackAccount({
-				cfg,
-				accountId
-			}),
-			defaultAccountId: (cfg) => resolveDefaultClickClackAccountId(cfg),
-			isConfigured: (account) => account.configured,
-			resolveAllowFrom: ({ cfg, accountId }) => resolveClickClackAccount({
-				cfg,
-				accountId
-			}).allowFrom,
-			resolveDefaultTo: ({ cfg, accountId }) => resolveClickClackAccount({
-				cfg,
-				accountId
-			}).defaultTo
+		config: clickClackConfigAdapter,
+		setup: clickClackSetupAdapter,
+		setupWizard: clickClackSetupWizard,
+		secrets: {
+			secretTargetRegistryEntries,
+			collectRuntimeConfigAssignments
 		},
 		messaging: {
 			targetPrefixes: ["clickclack", "cc"],
@@ -1627,4 +1333,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { getClickClackRuntime as a, DEFAULT_ACCOUNT_ID as c, resolveClickClackAccount as d, resolveDefaultClickClackAccountId as f, createClickClackClient as i, listClickClackAccountIds as l, buildClickClackTarget as n, setClickClackRuntime as o, parseClickClackTarget as r, clickClackConfigSchema as s, clickClackPlugin as t, listEnabledClickClackAccounts as u };
+export { setClickClackRuntime as a, getClickClackRuntime as i, buildClickClackTarget as n, parseClickClackTarget as r, clickClackPlugin as t };