@vama/openclaw 2026.5.5-6 → 2026.5.5-8

package/dist/channel-plugin-api-Bi8Gs3E6.js

@@ -0,0 +1,790 @@
+import { a as exchangeConnectCode, i as createBotHubClient, n as attachmentHintFromExtension, o as provisionBot } from "./client-BzhfASX8.js";
+import { a as resolveDefaultVamaAccountId, i as listVamaAccountIds, n as probeVama, o as resolveVamaAccount } from "./probe-COpuChEq.js";
+import { a as DEFAULT_ACCOUNT_ID$1, c as createDefaultChannelRuntimeState, n as sendMessageVama, o as PAIRING_APPROVED_MESSAGE, s as buildBaseChannelStatusSummary, t as monitorVamaProvider } from "./monitor-BlnFXk24.js";
+import { t as getVamaRuntime } from "./runtime-CQ9kld4S.js";
+import { t as parseVamaConnectCode } from "./connect-code-Bbp9J6TH.js";
+import { jsonResult, readStringOrNumberParam, readStringParam } from "openclaw/plugin-sdk/channel-actions";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, createStandardChannelSetupStatus, formatDocsLink, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+//#region extensions/vama/src/channel-actions.ts
+/**
+* Channel-actions adapter for the shared `message` agent tool.
+*
+* Vama bots previously had exactly one outbound-media mechanism: emit a
+* `MEDIA:/path/to/file` line inside the assistant reply text, which
+* `reply-dispatcher.ts` parses out and uploads via `client.sendFile`. That
+* path still works (see `reply-dispatcher.ts:parseInlineMediaTargets`) and
+* remains the default for normal turn replies — but it is brittle:
+*
+* - The model has to remember the exact format (line-start `MEDIA:` + path)
+* - Code-fenced or quoted variants don't match the line-anchored regex
+* - Long-context decay degrades format-directive following more than
+*   tool-call adherence on every frontier model
+* - There is no schema validation; mistakes silently become text replies
+*
+* Registering a `ChannelMessageActionAdapter` here mirrors the pattern used
+* by every other multimedia channel in openclaw (telegram, discord,
+* matrix, etc.). It exposes a structured `message({action: "send", to:
+* "<channelId>", media: "/path/to/file.html", caption: "..."})` tool call.
+* The platform's `message-action-discovery` layer picks this up and
+* publishes the right schema fragments on the agent's `message` tool. The
+* model now has two paths:
+*
+*   1. (Preferred) Call the `message` tool with `media`/`path`/`filePath`
+*      — schema-validated, returns a typed `{messageId, channelId}` tool
+*      result the model can read.
+*   2. (Fallback) Emit `MEDIA:/path` in plain text — `reply-dispatcher`
+*      still parses it.
+*
+* Both paths converge on the same `client.sendFile` underneath and the
+* same BotHub `POST /v1/bot/messages/file` endpoint. Existing dedup,
+* filename preservation, and attachment-hint inference are unchanged.
+*/
+/**
+* Extension-only file-extension helper. Duplicated from `outbound.ts` and
+* `reply-dispatcher.ts` rather than factored out — those copies are
+* intentionally narrow (basename-of-path slice, no normalisation) and we
+* want this adapter to behave identically. If a future refactor centralises
+* extension parsing in the plugin-SDK, all three sites can collapse.
+*/
+function extensionOf$1(path) {
+	const idx = path.lastIndexOf(".");
+	if (idx < 0 || idx === path.length - 1) return "";
+	if (idx < Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"))) return "";
+	return path.slice(idx + 1).toLowerCase();
+}
+/**
+* Resolve a media argument (typically the `media`, `path`, or `filePath`
+* field of the tool call) to a local filesystem path that
+* `BotHubClient.sendFile` can read. Mirrors `localPathFromMediaUrl` in
+* `outbound.ts` and `reply-dispatcher.ts` so all three Vama outbound
+* paths agree on which inputs count as "uploadable from disk".
+*
+* Remote URLs (`http://` / `https://`) return `null` — the outbound side
+* doesn't fetch remote bytes yet (no SSRF guard, no allowlist), so the
+* caller falls back to sending the URL inline as text. That matches the
+* fallback `outbound.ts:sendMedia` already implements.
+*/
+function localPathFromMediaArg(raw) {
+	if (raw.startsWith("file://")) return raw.slice(7);
+	if (raw.startsWith("/") || raw.startsWith("./")) return raw;
+	return null;
+}
+function describeVamaMessageTool({ cfg, accountId }) {
+	if (!resolveVamaAccount({
+		cfg,
+		accountId: accountId ?? void 0
+	}).configured) return {
+		actions: [],
+		capabilities: [],
+		schema: null
+	};
+	return {
+		actions: ["send"],
+		capabilities: [],
+		schema: null
+	};
+}
+/**
+* Read the channel/conversation target from the tool params. The model can
+* supply any of `to` / `channelId` / `target` (the last is the routing
+* schema's canonical name). Accept all three so a structured caller can
+* use whichever maps best to their context.
+*/
+function readVamaTarget(params) {
+	const value = readStringOrNumberParam(params, "to") ?? readStringOrNumberParam(params, "channelId") ?? readStringOrNumberParam(params, "target", { required: true });
+	if (!value) throw new Error("Vama send: target channel id required (use `to` or `channelId`)");
+	return value;
+}
+/**
+* Read the media argument the model supplied. The shared message tool
+* exposes three optional fields that can carry an attachment path: `media`
+* is openclaw's canonical name, `path` and `filePath` are the
+* historical aliases. Accept all three so we don't second-guess which
+* name the model picks.
+*/
+function readVamaMediaArg(params) {
+	return readStringParam(params, "media") ?? readStringParam(params, "path") ?? readStringParam(params, "filePath");
+}
+function readVamaCaption(params) {
+	return readStringParam(params, "caption") ?? readStringParam(params, "message");
+}
+function readVamaParentId(params) {
+	return readStringOrNumberParam(params, "replyTo") ?? readStringOrNumberParam(params, "replyToMessageId") ?? readStringOrNumberParam(params, "parentId");
+}
+const vamaMessageActions = {
+	describeMessageTool: describeVamaMessageTool,
+	resolveExecutionMode: () => "gateway",
+	extractToolSend: ({ args }) => extractToolSend(args, "send"),
+	handleAction: async ({ action, params, cfg, accountId }) => {
+		if (action !== "send") throw new Error(`Unsupported Vama action: ${action}`);
+		const account = resolveVamaAccount({
+			cfg,
+			accountId: accountId ?? void 0
+		});
+		if (!account.configured) throw new Error(`Vama account "${account.accountId}" not configured`);
+		const to = readVamaTarget(params);
+		const mediaArg = readVamaMediaArg(params);
+		const caption = readVamaCaption(params);
+		const parentId = readVamaParentId(params);
+		if (!mediaArg) {
+			const result = await sendMessageVama({
+				cfg,
+				to,
+				text: caption ?? "",
+				accountId: account.accountId,
+				parentId
+			});
+			return jsonResult({
+				ok: true,
+				messageId: result.messageId,
+				channelId: result.channelId
+			});
+		}
+		const localPath = localPathFromMediaArg(mediaArg);
+		if (!localPath) {
+			const result = await sendMessageVama({
+				cfg,
+				to,
+				text: caption?.trim() ? `${caption.trim()}\n${mediaArg}` : mediaArg,
+				accountId: account.accountId,
+				parentId
+			});
+			return jsonResult({
+				ok: true,
+				messageId: result.messageId,
+				channelId: result.channelId,
+				warning: "remote_media_unsupported_sent_as_link"
+			});
+		}
+		const result = await createBotHubClient(account).sendFile({
+			channelId: to,
+			path: localPath,
+			caption: caption?.trim() || void 0,
+			attachmentType: attachmentHintFromExtension(extensionOf$1(localPath)),
+			parentId
+		});
+		return jsonResult({
+			ok: true,
+			messageId: result.message_id,
+			channelId: result.channel_id
+		});
+	}
+};
+//#endregion
+//#region extensions/vama/src/outbound.ts
+/**
+* Resolve a media URL/path to a local filesystem path. The reply-dispatcher
+* normalises agent output through `splitMediaFromOutput` before reaching
+* the outbound adapter, so URLs are usually already absolute paths to
+* artefacts under the agent workspace (e.g.
+* `/home/app/.openclaw/workspace/output/foo.pdf`). Remote URLs (`http*`)
+* are not supported on the outbound side yet — we'd have to download them
+* first, which raises an SSRF question we'd rather defer until there's a
+* real producer. Returning `null` here causes the adapter to fall back to
+* sending the URL as plain text, preserving the legacy behaviour.
+*/
+function localPathFromMediaUrl(mediaUrl) {
+	if (mediaUrl.startsWith("file://")) return mediaUrl.slice(7);
+	if (mediaUrl.startsWith("/") || mediaUrl.startsWith("./")) return mediaUrl;
+	return null;
+}
+function extensionOf(path) {
+	const idx = path.lastIndexOf(".");
+	if (idx < 0 || idx === path.length - 1) return "";
+	if (idx < Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"))) return "";
+	return path.slice(idx + 1).toLowerCase();
+}
+const vamaOutbound = {
+	deliveryMode: "direct",
+	chunker: (text, limit) => getVamaRuntime().channel.text.chunkMarkdownText(text, limit),
+	chunkerMode: "markdown",
+	textChunkLimit: 1e4,
+	sendText: async ({ cfg, to, text, accountId }) => {
+		const result = await sendMessageVama({
+			cfg,
+			to,
+			text,
+			accountId: accountId ?? void 0
+		});
+		return {
+			channel: "vama",
+			messageId: result.messageId,
+			channelId: result.channelId
+		};
+	},
+	sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+		const account = resolveVamaAccount({
+			cfg,
+			accountId: accountId ?? void 0
+		});
+		if (!account.configured) throw new Error(`Vama account "${account.accountId}" not configured`);
+		if (!mediaUrl) {
+			const result = await sendMessageVama({
+				cfg,
+				to,
+				text: text ?? "",
+				accountId: accountId ?? void 0
+			});
+			return {
+				channel: "vama",
+				messageId: result.messageId,
+				channelId: result.channelId
+			};
+		}
+		const localPath = localPathFromMediaUrl(mediaUrl);
+		if (!localPath) {
+			const result = await sendMessageVama({
+				cfg,
+				to,
+				text: text && text.trim().length > 0 ? `${text.trim()}\n${mediaUrl}` : mediaUrl,
+				accountId: accountId ?? void 0
+			});
+			return {
+				channel: "vama",
+				messageId: result.messageId,
+				channelId: result.channelId
+			};
+		}
+		const result = await createBotHubClient(account).sendFile({
+			channelId: to,
+			path: localPath,
+			caption: text?.trim() || void 0,
+			attachmentType: attachmentHintFromExtension(extensionOf(localPath))
+		});
+		return {
+			channel: "vama",
+			messageId: result.message_id,
+			channelId: result.channel_id
+		};
+	}
+};
+//#endregion
+//#region extensions/vama/src/setup-surface.ts
+const channel = "vama";
+function setVamaDmPolicy(cfg, dmPolicy) {
+	const allowFrom = dmPolicy === "open" ? addWildcardAllowFrom(cfg.channels?.vama?.allowFrom)?.map((entry) => entry) : void 0;
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			vama: {
+				...cfg.channels?.vama,
+				dmPolicy,
+				...allowFrom ? { allowFrom } : {}
+			}
+		}
+	};
+}
+function setVamaAllowFrom(cfg, allowFrom) {
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			vama: {
+				...cfg.channels?.vama,
+				allowFrom
+			}
+		}
+	};
+}
+function parseAllowFromInput(raw) {
+	return raw.split(/[\n,;]+/g).map((entry) => entry.trim()).filter(Boolean);
+}
+async function promptVamaAllowFrom(params) {
+	const existing = params.cfg.channels?.vama?.allowFrom ?? [];
+	await params.prompter.note(["Allowlist Vama DMs by user ID.", "Enter one or more Vama user IDs, separated by commas."].join("\n"), "Vama allowlist");
+	while (true) {
+		const parts = parseAllowFromInput(await params.prompter.text({
+			message: "Vama allowFrom (user IDs)",
+			placeholder: "user_xxxxx, user_yyyyy",
+			initialValue: existing[0] ? String(existing[0]) : void 0,
+			validate: (value) => (value ?? "").trim() ? void 0 : "Required"
+		}));
+		if (parts.length === 0) {
+			await params.prompter.note("Enter at least one user.", "Vama allowlist");
+			continue;
+		}
+		const unique = [...new Set([...existing.map((v) => String(v).trim()).filter(Boolean), ...parts])];
+		return setVamaAllowFrom(params.cfg, unique);
+	}
+}
+const vamaDmPolicy = {
+	label: "Vama",
+	channel,
+	policyKey: "channels.vama.dmPolicy",
+	allowFromKey: "channels.vama.allowFrom",
+	getCurrent: (cfg) => (cfg.channels?.vama)?.dmPolicy ?? "open",
+	setPolicy: (cfg, policy) => setVamaDmPolicy(cfg, policy),
+	promptAllowFrom: promptVamaAllowFrom
+};
+const vamaPlugin = {
+	id: "vama",
+	meta: {
+		id: "vama",
+		label: "Vama",
+		selectionLabel: "Vama",
+		docsPath: "/channels/vama",
+		docsLabel: "vama",
+		blurb: "Vama chat integration via BotHub.",
+		order: 80
+	},
+	pairing: {
+		idLabel: "vamaUserId",
+		normalizeAllowEntry: (entry) => entry.trim(),
+		notifyApproval: async ({ cfg, id }) => {
+			const account = resolveVamaAccount({ cfg });
+			if (!account.configured) return;
+			try {
+				const { createBotHubClient } = await import("./client-BzhfASX8.js").then((n) => n.r);
+				await createBotHubClient(account).sendMessage({
+					userId: id,
+					text: PAIRING_APPROVED_MESSAGE
+				});
+			} catch {}
+		}
+	},
+	capabilities: {
+		chatTypes: ["direct"],
+		polls: false,
+		threads: true,
+		media: true,
+		reactions: false,
+		edit: false,
+		reply: true
+	},
+	reload: { configPrefixes: ["channels.vama"] },
+	configSchema: { schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			enabled: { type: "boolean" },
+			botToken: { type: "string" },
+			webhookSecret: { type: "string" },
+			webhookSecretFile: { type: "string" },
+			bothubUrl: { type: "string" },
+			webhookPath: { type: "string" },
+			webhookPort: {
+				type: "integer",
+				minimum: 1
+			},
+			webhookHost: { type: "string" },
+			webhookUrl: { type: "string" },
+			transport: {
+				type: "string",
+				enum: [
+					"auto",
+					"webhook",
+					"websocket"
+				]
+			},
+			dmPolicy: {
+				type: "string",
+				enum: [
+					"open",
+					"pairing",
+					"allowlist"
+				]
+			},
+			allowFrom: {
+				type: "array",
+				items: { oneOf: [{ type: "string" }, { type: "number" }] }
+			},
+			textChunkLimit: {
+				type: "integer",
+				minimum: 1
+			},
+			accounts: {
+				type: "object",
+				additionalProperties: {
+					type: "object",
+					properties: {
+						enabled: { type: "boolean" },
+						name: { type: "string" },
+						botToken: { type: "string" },
+						webhookSecret: { type: "string" },
+						webhookSecretFile: { type: "string" },
+						bothubUrl: { type: "string" },
+						webhookPath: { type: "string" },
+						webhookPort: {
+							type: "integer",
+							minimum: 1
+						},
+						webhookHost: { type: "string" },
+						webhookUrl: { type: "string" },
+						transport: {
+							type: "string",
+							enum: [
+								"auto",
+								"webhook",
+								"websocket"
+							]
+						}
+					}
+				}
+			}
+		}
+	} },
+	config: {
+		listAccountIds: (cfg) => listVamaAccountIds(cfg),
+		resolveAccount: (cfg, accountId) => resolveVamaAccount({
+			cfg,
+			accountId
+		}),
+		defaultAccountId: (cfg) => resolveDefaultVamaAccountId(cfg),
+		setAccountEnabled: ({ cfg, accountId, enabled }) => {
+			if (accountId === DEFAULT_ACCOUNT_ID$1) return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					vama: {
+						...cfg.channels?.vama,
+						enabled
+					}
+				}
+			};
+			const vamaCfg = cfg.channels?.vama;
+			return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					vama: {
+						...vamaCfg,
+						accounts: {
+							...vamaCfg?.accounts,
+							[accountId]: {
+								...vamaCfg?.accounts?.[accountId],
+								enabled
+							}
+						}
+					}
+				}
+			};
+		},
+		deleteAccount: ({ cfg, accountId }) => {
+			if (accountId === DEFAULT_ACCOUNT_ID$1) {
+				const next = { ...cfg };
+				const nextChannels = { ...cfg.channels };
+				delete nextChannels.vama;
+				if (Object.keys(nextChannels).length > 0) next.channels = nextChannels;
+				else delete next.channels;
+				return next;
+			}
+			const vamaCfg = cfg.channels?.vama;
+			const accounts = { ...vamaCfg?.accounts };
+			delete accounts[accountId];
+			return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					vama: {
+						...vamaCfg,
+						accounts: Object.keys(accounts).length > 0 ? accounts : void 0
+					}
+				}
+			};
+		},
+		isConfigured: (account) => account.configured,
+		describeAccount: (account) => ({
+			accountId: account.accountId,
+			enabled: account.enabled,
+			configured: account.configured,
+			name: account.name,
+			bothubUrl: account.bothubUrl
+		}),
+		resolveAllowFrom: ({ cfg, accountId }) => {
+			return (resolveVamaAccount({
+				cfg,
+				accountId
+			}).config?.allowFrom ?? []).map((entry) => String(entry));
+		},
+		formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean)
+	},
+	security: { collectWarnings: ({ cfg, accountId }) => {
+		const account = resolveVamaAccount({
+			cfg,
+			accountId
+		});
+		if ((account.config?.dmPolicy ?? "open") !== "open") return [];
+		return [`- Vama[${account.accountId}]: dmPolicy="open" allows any user to DM the bot. Set channels.vama.dmPolicy="allowlist" + channels.vama.allowFrom to restrict senders.`];
+	} },
+	setup: {
+		resolveAccountId: () => DEFAULT_ACCOUNT_ID$1,
+		applyAccountConfig: ({ cfg, accountId }) => {
+			if (!accountId || accountId === DEFAULT_ACCOUNT_ID$1) return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					vama: {
+						...cfg.channels?.vama,
+						enabled: true
+					}
+				}
+			};
+			const vamaCfg = cfg.channels?.vama;
+			return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					vama: {
+						...vamaCfg,
+						accounts: {
+							...vamaCfg?.accounts,
+							[accountId]: {
+								...vamaCfg?.accounts?.[accountId],
+								enabled: true
+							}
+						}
+					}
+				}
+			};
+		}
+	},
+	setupWizard: {
+		channel,
+		status: createStandardChannelSetupStatus({
+			channelLabel: "Vama",
+			configuredLabel: "configured",
+			unconfiguredLabel: "needs BotHub credentials",
+			configuredHint: "configured",
+			unconfiguredHint: "needs credentials",
+			configuredScore: 2,
+			unconfiguredScore: 0,
+			includeStatusLine: true,
+			resolveConfigured: ({ cfg }) => resolveVamaAccount({ cfg }).configured
+		}),
+		introNote: {
+			title: "Vama setup",
+			lines: [
+				"Easiest: paste a connect code from the Vama app (Settings → AI Agents).",
+				"Alternative: provision a bot by Vama username.",
+				`Docs: ${formatDocsLink("/channels/vama", "channels/vama")}`
+			],
+			shouldShow: ({ cfg }) => !resolveVamaAccount({ cfg }).configured
+		},
+		resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
+		resolveShouldPromptAccountIds: () => false,
+		credentials: [],
+		finalize: async ({ cfg, prompter }) => {
+			const vamaCfg = cfg.channels?.vama;
+			const hasCredentials = Boolean(vamaCfg?.botToken?.trim());
+			let next = cfg;
+			if (hasCredentials) {
+				if (await prompter.confirm({
+					message: "Vama credentials already configured. Keep them?",
+					initialValue: true
+				})) {
+					next = {
+						...next,
+						channels: {
+							...next.channels,
+							vama: {
+								...next.channels?.vama,
+								enabled: true
+							}
+						}
+					};
+					return { cfg: next };
+				}
+			}
+			if (await prompter.select({
+				message: "How do you want to connect to Vama?",
+				options: [{
+					value: "code",
+					label: "Paste a connect code (recommended)",
+					hint: "Vama app → Settings → AI Agents → Connect your own — no tunnel needed"
+				}, {
+					value: "username",
+					label: "Provision by Vama username",
+					hint: "creates/reuses a bot for your account; webhook URL needed later"
+				}],
+				initialValue: "code"
+			}) === "code") {
+				const parsedCode = parseVamaConnectCode((await prompter.text({
+					message: "Connect code (vmc1_… or 64-char hex)",
+					validate: (value) => {
+						try {
+							parseVamaConnectCode(value ?? "");
+							return;
+						} catch (err) {
+							return err instanceof Error ? err.message : String(err);
+						}
+					}
+				})).trim());
+				const codeBothubUrl = parsedCode.bothubUrl || vamaCfg?.bothubUrl?.trim() || "https://bothub.vama.com";
+				await prompter.note("Exchanging connect code with BotHub...", "Vama setup");
+				try {
+					const exchanged = await exchangeConnectCode({
+						bothubUrl: codeBothubUrl,
+						code: parsedCode.code
+					});
+					next = {
+						...next,
+						channels: {
+							...next.channels,
+							vama: {
+								...next.channels?.vama,
+								enabled: true,
+								botToken: exchanged.bot_token,
+								webhookSecret: exchanged.webhook_secret,
+								...codeBothubUrl !== "https://bothub.vama.com" ? { bothubUrl: codeBothubUrl } : {}
+							}
+						}
+					};
+					const label = exchanged.display_name || exchanged.username || exchanged.bot_id;
+					await prompter.note(exchanged.websocket_enabled ? `Connected as ${label}. WebSocket delivery is enabled — no tunnel or public URL needed.` : `Connected as ${label}. This bot uses webhook delivery — set channels.vama.webhookUrl once your gateway is publicly reachable.`, "Vama connect");
+				} catch (err) {
+					await prompter.note(`Connect code exchange failed: ${err instanceof Error ? err.message : String(err)}\nMint a fresh code in Vama settings, or re-run setup and choose username provisioning.`, "Vama connect error");
+					return { cfg: next };
+				}
+				const account = resolveVamaAccount({ cfg: next });
+				try {
+					const probe = await probeVama(account);
+					await prompter.note(probe.ok ? `Connected successfully (bot ${probe.botId ?? "unknown"})` : `Connection test failed: ${probe.error ?? "unknown error"}`, "Vama connection test");
+				} catch (err) {
+					await prompter.note(`Connection test failed: ${String(err)}`, "Vama connection test");
+				}
+				return { cfg: next };
+			}
+			const bothubUrl = vamaCfg?.bothubUrl?.trim() || "https://bothub.vama.com";
+			const username = (await prompter.text({
+				message: "Your Vama username (for bot provisioning)",
+				validate: (value) => (value ?? "").trim() ? void 0 : "Required"
+			})).trim();
+			await prompter.note("Provisioning bot via BotHub...", "Vama setup");
+			let botToken;
+			let webhookSecret;
+			try {
+				const result = await provisionBot({
+					bothubUrl,
+					targetUsername: username
+				});
+				botToken = result.bot_token;
+				webhookSecret = result.webhook_secret;
+				const status = result.created ? "New bot created" : "Existing bot re-provisioned";
+				await prompter.note(`${status} (ID: ${result.bot_id})`, "Vama provisioning");
+			} catch (err) {
+				await prompter.note(`Provisioning failed: ${String(err)}\nYou can manually set botToken and webhookSecret in the config.`, "Vama provisioning error");
+				return { cfg: next };
+			}
+			const webhookPort = Number(await prompter.text({
+				message: "Webhook port (for receiving messages)",
+				initialValue: String(vamaCfg?.webhookPort ?? 3001),
+				validate: (value) => {
+					const n = Number(value);
+					if (Number.isNaN(n) || n < 1 || n > 65535) return "Must be a valid port (1-65535)";
+				}
+			}));
+			next = {
+				...next,
+				channels: {
+					...next.channels,
+					vama: {
+						...next.channels?.vama,
+						enabled: true,
+						botToken,
+						webhookSecret,
+						bothubUrl,
+						webhookPort
+					}
+				}
+			};
+			const publicWebhookUrl = (await prompter.text({
+				message: "Public webhook URL for BotHub to send events (leave blank to skip)",
+				placeholder: "https://your-gateway-host.example.com/vama/events",
+				initialValue: "",
+				validate: (value) => {
+					const v = (value ?? "").trim();
+					if (!v) return;
+					try {
+						new URL(v);
+						return;
+					} catch {
+						return "Must be a valid URL (or leave blank to skip)";
+					}
+				}
+			})).trim();
+			if (publicWebhookUrl) {
+				next = {
+					...next,
+					channels: {
+						...next.channels,
+						vama: {
+							...next.channels?.vama,
+							webhookUrl: publicWebhookUrl
+						}
+					}
+				};
+				try {
+					await createBotHubClient(resolveVamaAccount({ cfg: next })).registerWebhook({ url: publicWebhookUrl });
+					await prompter.note(`Webhook registered: ${publicWebhookUrl}`, "Vama webhook registration");
+				} catch (err) {
+					await prompter.note(`Webhook registration failed: ${String(err)}\nThe gateway will retry automatically at startup (channels.vama.webhookUrl is saved).`, "Vama webhook registration");
+				}
+			} else await prompter.note("Skipped webhook registration. Once your gateway is publicly reachable, set channels.vama.webhookUrl to its public URL (e.g. https://your-host/vama/events) — it registers automatically at startup.", "Vama webhook registration");
+			const account = resolveVamaAccount({ cfg: next });
+			try {
+				const probe = await probeVama(account);
+				if (probe.ok) await prompter.note(`Connected successfully (bot ${probe.botId ?? "unknown"})`, "Vama connection test");
+				else await prompter.note(`Connection test failed: ${probe.error ?? "unknown error"}`, "Vama connection test");
+			} catch (err) {
+				await prompter.note(`Connection test failed: ${String(err)}`, "Vama connection test");
+			}
+			return { cfg: next };
+		},
+		completionNote: {
+			title: "Vama next steps",
+			lines: [
+				"Next: restart gateway and verify status.",
+				"Command: openclaw channels status --probe",
+				`Docs: ${formatDocsLink("/channels/vama", "channels/vama")}`
+			]
+		},
+		dmPolicy: vamaDmPolicy,
+		disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+	},
+	outbound: vamaOutbound,
+	actions: vamaMessageActions,
+	status: {
+		defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID$1, { port: null }),
+		buildChannelSummary: ({ snapshot }) => ({
+			...buildBaseChannelStatusSummary(snapshot),
+			port: snapshot.port ?? null,
+			probe: snapshot.probe,
+			lastProbeAt: snapshot.lastProbeAt ?? null
+		}),
+		probeAccount: async ({ account }) => await probeVama(account),
+		buildAccountSnapshot: ({ account, runtime, probe }) => ({
+			accountId: account.accountId,
+			enabled: account.enabled,
+			configured: account.configured,
+			name: account.name,
+			bothubUrl: account.bothubUrl,
+			running: runtime?.running ?? false,
+			lastStartAt: runtime?.lastStartAt ?? null,
+			lastStopAt: runtime?.lastStopAt ?? null,
+			lastError: runtime?.lastError ?? null,
+			port: runtime?.port ?? null,
+			probe
+		})
+	},
+	gateway: { startAccount: async (ctx) => {
+		const port = resolveVamaAccount({
+			cfg: ctx.cfg,
+			accountId: ctx.accountId
+		}).config?.webhookPort ?? null;
+		ctx.setStatus({
+			accountId: ctx.accountId,
+			port
+		});
+		ctx.log?.info(`starting vama[${ctx.accountId}]`);
+		return monitorVamaProvider({
+			config: ctx.cfg,
+			runtime: ctx.runtime,
+			abortSignal: ctx.abortSignal,
+			accountId: ctx.accountId
+		});
+	} }
+};
+//#endregion
+export { vamaPlugin as t };