@openclaw/clickclack 2026.7.1 → 2026.7.2-beta.2

package/dist/{channel-1ZnJZTPl.js → channel-BnREQIP8.js}

@@ -1,155 +1,17 @@
-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-B346XaAu.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 } from "openclaw/plugin-sdk/channel-outbound";
-import { getChatChannelMeta } from "openclaw/plugin-sdk/channel-plugin-common";
+import { buildChannelProgressDraftLine, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, deriveDurableFinalDeliveryRequirements } from "openclaw/plugin-sdk/channel-outbound";
 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 { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-//#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
+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/runtime.ts
 /**
 * Runtime store for host-provided OpenClaw services used by the ClickClack
@@ -212,139 +74,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;
-/**
-* 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 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 (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 Error(`ClickClack ${response.status}: ${detail}`);
+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;
 		}
-		return await readProviderJsonResponse(response, "ClickClack response");
+		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`),
-		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 } : {},
-					...provenanceFields(opts?.provenance)
-				})
-			})).message;
-		},
-		createThreadReply: async (messageId, body, opts) => {
-			return (await request(`/api/messages/${encodeURIComponent(messageId)}/thread/replies`, {
-				method: "POST",
-				body: JSON.stringify({
-					body,
-					...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;
-		},
-		/**
-		* 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 } : {}
-				})
-			})).message;
-		},
-		events: async (workspaceId, afterCursor) => {
-			const query = new URLSearchParams({ workspace_id: workspaceId });
-			if (afterCursor) query.set("after_cursor", afterCursor);
-			return (await request(`/api/realtime/events?${query.toString()}`)).events;
-		},
-		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}` } });
+	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
@@ -542,27 +327,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.
@@ -612,52 +376,285 @@ function looksLikeClickClackTarget(raw) {
 * Outbound ClickClack delivery helpers for channel messages, thread replies,
 * and direct messages.
 */
-/**
-* Sends text to a normalized ClickClack target and returns the created message
-* id for receipt/session tracking.
-*/
-async function sendClickClackText(params) {
+const CLICKCLACK_MAX_UPLOAD_BYTES = 64 * 1024 * 1024;
+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
 	});
-	const client = createClickClackClient({
-		baseUrl: account.baseUrl,
-		token: account.token
+	return {
+		account,
+		client: createClickClackClient({
+			baseUrl: account.baseUrl,
+			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 = 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 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;
-		const message = await client.createThreadReply(rootId, params.text, { provenance: params.provenance });
+	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 = 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 {
-			to: params.to,
-			messageId: message.id
+			status: "sent",
+			messageId: message.id,
+			receipt
 		};
 	}
-	if (parsed.kind === "dm") {
-		const dm = await client.createDirectConversation(workspaceId, [parsed.id]);
-		const message = await client.createDirectMessage(dm.id, params.text, { quotedMessageId: replyToId || void 0 });
+	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 {
-			to: params.to,
-			messageId: message.id
+			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 channelId = await resolveChannelId(client, workspaceId, parsed.id);
-	const message = await client.createChannelMessage(channelId, params.text, {
-		provenance: params.provenance,
-		quotedMessageId: replyToId || void 0
+	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 {
-		to: params.to,
-		messageId: message.id
+		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({
@@ -702,10 +699,10 @@ function resolveAccountAgentRoute(params) {
 	};
 }
 async function dispatchModelReply(params) {
-	const text = (await getClickClackRuntime().llm.complete({
+	const runtime = getClickClackRuntime();
+	const text = (await runtime.llm.complete({
 		agentId: params.route.agentId,
 		model: params.account.model,
-		maxTokens: 96,
 		purpose: "clickclack bot reply",
 		systemPrompt: params.account.systemPrompt,
 		messages: [{
@@ -713,14 +710,21 @@ async function dispatchModelReply(params) {
 			content: params.message.body
 		}]
 	})).text.trim();
-	if (!text) return;
+	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
+		replyToId: params.message.id,
+		correlationId: params.correlationId
 	});
 }
 /**
@@ -758,7 +762,8 @@ async function handleClickClackInbound(params) {
 			cfg: params.config,
 			message,
 			route,
-			target
+			target,
+			correlationId: params.correlationId
 		});
 		return;
 	}
@@ -767,7 +772,8 @@ async function handleClickClackInbound(params) {
 	if (params.account.agentActivity && (message.channel_id || message.direct_conversation_id)) activity = createClickClackActivityPublisher({
 		client: createClickClackClient({
 			baseUrl: params.account.baseUrl,
-			token: params.account.token
+			token: params.account.token,
+			correlationId: params.correlationId
 		}),
 		target: message.channel_id ? { channelId: message.channel_id } : { conversationId: message.direct_conversation_id },
 		turnId: message.id,
@@ -820,6 +826,20 @@ async function handleClickClackInbound(params) {
 		OriginatingTo: target,
 		CommandAuthorized: access.commandAuthorized
 	});
+	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.dispatchReply({
 		cfg: params.config,
 		channel: CHANNEL_ID$1,
@@ -831,21 +851,13 @@ async function handleClickClackInbound(params) {
 		recordInboundSession: runtime.channel.session.recordInboundSession,
 		dispatchReplyWithBufferedBlockDispatcher: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		toolsAllow: params.account.toolsAllow,
-		replyOptions: 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
+		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({
@@ -855,9 +867,25 @@ async function handleClickClackInbound(params) {
 					text,
 					threadId: message.parent_message_id ? message.thread_root_id : void 0,
 					replyToId: message.id,
-					provenance: turnProvenance
+					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)}`);
 			}
@@ -875,10 +903,14 @@ async function handleClickClackInbound(params) {
 }
 //#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;
@@ -908,8 +940,13 @@ function parseSocketEvent(data) {
 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: params.client,
+		client: correlationId ? createClickClackClient({
+			baseUrl: params.account.baseUrl,
+			token: params.account.token,
+			correlationId
+		}) : params.client,
 		event: params.event
 	});
 	if (!message || message.author_id === params.botUserId) return;
@@ -924,9 +961,27 @@ async function processEvent(params) {
 		account: params.account,
 		config: params.config,
 		message,
-		access
+		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,
@@ -944,6 +999,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,
@@ -955,23 +1022,25 @@ async function startClickClackGatewayAccount(ctx) {
 	let initialized = false;
 	try {
 		while (!ctx.abortSignal.aborted) {
-			const backlog = await client.events(workspaceId, afterCursor);
 			if (!initialized) {
-				for (const event of backlog) afterCursor = event.cursor || afterCursor;
+				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 for (const event of backlog) {
-				afterCursor = event.cursor || afterCursor;
-				await processEvent({
-					account,
-					config: ctx.cfg,
-					client,
-					event,
-					botUserId: account.botUserId
-				});
-			}
+			} 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, 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;
@@ -980,6 +1049,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();
@@ -987,36 +1070,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({
@@ -1031,40 +1116,84 @@ 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: { capabilities: {
-		text: true,
-		replyTo: true,
-		thread: true,
-		messageSendingHooks: true
-	} },
-	send: { text: async (ctx) => {
-		const result = await sendClickClackText({
-			cfg: ctx.cfg,
-			accountId: ctx.accountId,
-			to: ctx.to,
-			text: ctx.text,
-			threadId: ctx.threadId,
-			replyToId: ctx.replyToId
-		});
-		const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
-		const replyToId = ctx.replyToId ?? void 0;
-		return {
-			messageId: result.messageId,
-			receipt: createMessageReceiptFromOutboundResults({
-				results: [{
-					channel: CHANNEL_ID,
-					messageId: result.messageId
-				}],
-				threadId,
-				replyToId,
-				kind: "text"
-			})
-		};
-	} }
+	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.
@@ -1072,7 +1201,7 @@ const clickClackMessageAdapter = defineChannelMessageAdapter({
 const clickClackPlugin = createChatChannelPlugin({
 	base: {
 		id: CHANNEL_ID,
-		meta,
+		meta: clickClackMeta,
 		capabilities: {
 			chatTypes: ["direct", "group"],
 			threads: true,
@@ -1080,22 +1209,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"],
@@ -1162,16 +1281,39 @@ const clickClackPlugin = createChatChannelPlugin({
 		base: { deliveryMode: "direct" },
 		attachedResults: {
 			channel: CHANNEL_ID,
-			sendText: async ({ cfg, to, text, accountId, threadId, replyToId }) => await sendClickClackText({
-				cfg,
-				accountId,
-				to,
-				text,
-				threadId,
-				replyToId
-			})
+			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 { 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 };