@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/auto-reply/auto-reply/reply/commands-info.js

@@ -0,0 +1,184 @@
+import { logVerbose } from "../../globals.js";
+import { listSkillCommandsForAgents } from "../skill-commands.js";
+import { buildCommandsMessage, buildCommandsMessagePaginated, buildHelpMessage, } from "../status.js";
+import { buildContextReply } from "./commands-context-report.js";
+import { buildExportSessionReply } from "./commands-export-session.js";
+import { buildStatusReply } from "./commands-status.js";
+export const handleHelpCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    if (params.command.commandBodyNormalized !== "/help") {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /help from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    return {
+        shouldContinue: false,
+        reply: { text: buildHelpMessage(params.cfg) },
+    };
+};
+export const handleCommandsListCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    if (params.command.commandBodyNormalized !== "/commands") {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /commands from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    const skillCommands = params.skillCommands ??
+        listSkillCommandsForAgents({
+            cfg: params.cfg,
+            agentIds: params.agentId ? [params.agentId] : undefined,
+        });
+    const surface = params.ctx.Surface;
+    if (surface === "telegram") {
+        const result = buildCommandsMessagePaginated(params.cfg, skillCommands, {
+            page: 1,
+            surface,
+        });
+        if (result.totalPages > 1) {
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: result.text,
+                    channelData: {
+                        telegram: {
+                            buttons: buildCommandsPaginationKeyboard(result.currentPage, result.totalPages, params.agentId),
+                        },
+                    },
+                },
+            };
+        }
+        return {
+            shouldContinue: false,
+            reply: { text: result.text },
+        };
+    }
+    return {
+        shouldContinue: false,
+        reply: { text: buildCommandsMessage(params.cfg, skillCommands, { surface }) },
+    };
+};
+export function buildCommandsPaginationKeyboard(currentPage, totalPages, agentId) {
+    const buttons = [];
+    const suffix = agentId ? `:${agentId}` : "";
+    if (currentPage > 1) {
+        buttons.push({
+            text: "◀ Prev",
+            callback_data: `commands_page_${currentPage - 1}${suffix}`,
+        });
+    }
+    buttons.push({
+        text: `${currentPage}/${totalPages}`,
+        callback_data: `commands_page_noop${suffix}`,
+    });
+    if (currentPage < totalPages) {
+        buttons.push({
+            text: "Next ▶",
+            callback_data: `commands_page_${currentPage + 1}${suffix}`,
+        });
+    }
+    return [buttons];
+}
+export const handleStatusCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const statusRequested = params.directives.hasStatusDirective || params.command.commandBodyNormalized === "/status";
+    if (!statusRequested) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /status from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    const reply = await buildStatusReply({
+        cfg: params.cfg,
+        command: params.command,
+        sessionEntry: params.sessionEntry,
+        sessionKey: params.sessionKey,
+        parentSessionKey: params.ctx.ParentSessionKey,
+        sessionScope: params.sessionScope,
+        provider: params.provider,
+        model: params.model,
+        contextTokens: params.contextTokens,
+        resolvedThinkLevel: params.resolvedThinkLevel,
+        resolvedVerboseLevel: params.resolvedVerboseLevel,
+        resolvedReasoningLevel: params.resolvedReasoningLevel,
+        resolvedElevatedLevel: params.resolvedElevatedLevel,
+        resolveDefaultThinkingLevel: params.resolveDefaultThinkingLevel,
+        isGroup: params.isGroup,
+        defaultGroupActivation: params.defaultGroupActivation,
+        mediaDecisions: params.ctx.MediaUnderstandingDecisions,
+    });
+    return { shouldContinue: false, reply };
+};
+export const handleContextCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const normalized = params.command.commandBodyNormalized;
+    if (normalized !== "/context" && !normalized.startsWith("/context ")) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /context from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    return { shouldContinue: false, reply: await buildContextReply(params) };
+};
+export const handleExportSessionCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const normalized = params.command.commandBodyNormalized;
+    if (normalized !== "/export-session" &&
+        !normalized.startsWith("/export-session ") &&
+        normalized !== "/export" &&
+        !normalized.startsWith("/export ")) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /export-session from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    return { shouldContinue: false, reply: await buildExportSessionReply(params) };
+};
+export const handleWhoamiCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    if (params.command.commandBodyNormalized !== "/whoami") {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /whoami from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    const senderId = params.ctx.SenderId ?? "";
+    const senderUsername = params.ctx.SenderUsername ?? "";
+    const lines = ["🧭 Identity", `Channel: ${params.command.channel}`];
+    if (senderId) {
+        lines.push(`User id: ${senderId}`);
+    }
+    if (senderUsername) {
+        const handle = senderUsername.startsWith("@") ? senderUsername : `@${senderUsername}`;
+        lines.push(`Username: ${handle}`);
+    }
+    if (params.ctx.ChatType === "group" && params.ctx.From) {
+        lines.push(`Chat: ${params.ctx.From}`);
+    }
+    if (params.ctx.MessageThreadId != null) {
+        lines.push(`Thread: ${params.ctx.MessageThreadId}`);
+    }
+    if (senderId) {
+        lines.push(`AllowFrom: ${senderId}`);
+    }
+    return { shouldContinue: false, reply: { text: lines.join("\n") } };
+};

package/dist/auto-reply/auto-reply/reply/commands-models.js

@@ -0,0 +1,299 @@
+import { resolveAgentDir, resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
+import { resolveModelAuthLabel } from "../../agents/model-auth-label.js";
+import { loadModelCatalog } from "../../agents/model-catalog.js";
+import { buildAllowedModelSet, buildModelAliasIndex, normalizeProviderId, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
+import { buildModelsKeyboard, buildProviderKeyboard, calculateTotalPages, getModelsPageSize, } from "../../telegram/model-buttons.js";
+const PAGE_SIZE_DEFAULT = 20;
+const PAGE_SIZE_MAX = 100;
+/**
+ * Build provider/model data from config and catalog.
+ * Exported for reuse by callback handlers.
+ */
+export async function buildModelsProviderData(cfg) {
+    const resolvedDefault = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const catalog = await loadModelCatalog({ config: cfg });
+    const allowed = buildAllowedModelSet({
+        cfg,
+        catalog,
+        defaultProvider: resolvedDefault.provider,
+        defaultModel: resolvedDefault.model,
+    });
+    const aliasIndex = buildModelAliasIndex({
+        cfg,
+        defaultProvider: resolvedDefault.provider,
+    });
+    const byProvider = new Map();
+    const add = (p, m) => {
+        const key = normalizeProviderId(p);
+        const set = byProvider.get(key) ?? new Set();
+        set.add(m);
+        byProvider.set(key, set);
+    };
+    const addRawModelRef = (raw) => {
+        const trimmed = raw?.trim();
+        if (!trimmed) {
+            return;
+        }
+        const resolved = resolveModelRefFromString({
+            raw: trimmed,
+            defaultProvider: resolvedDefault.provider,
+            aliasIndex,
+        });
+        if (!resolved) {
+            return;
+        }
+        add(resolved.ref.provider, resolved.ref.model);
+    };
+    const addModelConfigEntries = () => {
+        const modelConfig = cfg.agents?.defaults?.model;
+        if (typeof modelConfig === "string") {
+            addRawModelRef(modelConfig);
+        }
+        else if (modelConfig && typeof modelConfig === "object") {
+            addRawModelRef(modelConfig.primary);
+            for (const fallback of modelConfig.fallbacks ?? []) {
+                addRawModelRef(fallback);
+            }
+        }
+        const imageConfig = cfg.agents?.defaults?.imageModel;
+        if (typeof imageConfig === "string") {
+            addRawModelRef(imageConfig);
+        }
+        else if (imageConfig && typeof imageConfig === "object") {
+            addRawModelRef(imageConfig.primary);
+            for (const fallback of imageConfig.fallbacks ?? []) {
+                addRawModelRef(fallback);
+            }
+        }
+    };
+    for (const entry of allowed.allowedCatalog) {
+        add(entry.provider, entry.id);
+    }
+    // Include config-only allowlist keys that aren't in the curated catalog.
+    for (const raw of Object.keys(cfg.agents?.defaults?.models ?? {})) {
+        addRawModelRef(raw);
+    }
+    // Ensure configured defaults/fallbacks/image models show up even when the
+    // curated catalog doesn't know about them (custom providers, dev builds, etc.).
+    add(resolvedDefault.provider, resolvedDefault.model);
+    addModelConfigEntries();
+    const providers = [...byProvider.keys()].toSorted();
+    return { byProvider, providers, resolvedDefault };
+}
+function formatProviderLine(params) {
+    return `- ${params.provider} (${params.count})`;
+}
+function parseModelsArgs(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return { page: 1, pageSize: PAGE_SIZE_DEFAULT, all: false };
+    }
+    const tokens = trimmed.split(/\s+/g).filter(Boolean);
+    const provider = tokens[0]?.trim();
+    let page = 1;
+    let all = false;
+    for (const token of tokens.slice(1)) {
+        const lower = token.toLowerCase();
+        if (lower === "all" || lower === "--all") {
+            all = true;
+            continue;
+        }
+        if (lower.startsWith("page=")) {
+            const value = Number.parseInt(lower.slice("page=".length), 10);
+            if (Number.isFinite(value) && value > 0) {
+                page = value;
+            }
+            continue;
+        }
+        if (/^[0-9]+$/.test(lower)) {
+            const value = Number.parseInt(lower, 10);
+            if (Number.isFinite(value) && value > 0) {
+                page = value;
+            }
+        }
+    }
+    let pageSize = PAGE_SIZE_DEFAULT;
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (lower.startsWith("limit=") || lower.startsWith("size=")) {
+            const rawValue = lower.slice(lower.indexOf("=") + 1);
+            const value = Number.parseInt(rawValue, 10);
+            if (Number.isFinite(value) && value > 0) {
+                pageSize = Math.min(PAGE_SIZE_MAX, value);
+            }
+        }
+    }
+    return {
+        provider: provider ? normalizeProviderId(provider) : undefined,
+        page,
+        pageSize,
+        all,
+    };
+}
+function resolveProviderLabel(params) {
+    const authLabel = resolveModelAuthLabel({
+        provider: params.provider,
+        cfg: params.cfg,
+        sessionEntry: params.sessionEntry,
+        agentDir: params.agentDir,
+    });
+    if (!authLabel || authLabel === "unknown") {
+        return params.provider;
+    }
+    return `${params.provider} \u00b7 \uD83D\uDD11 ${authLabel}`;
+}
+export function formatModelsAvailableHeader(params) {
+    const providerLabel = resolveProviderLabel({
+        provider: params.provider,
+        cfg: params.cfg,
+        agentDir: params.agentDir,
+        sessionEntry: params.sessionEntry,
+    });
+    return `Models (${providerLabel}) \u2014 ${params.total} available`;
+}
+export async function resolveModelsCommandReply(params) {
+    const body = params.commandBodyNormalized.trim();
+    if (!body.startsWith("/models")) {
+        return null;
+    }
+    const argText = body.replace(/^\/models\b/i, "").trim();
+    const { provider, page, pageSize, all } = parseModelsArgs(argText);
+    const { byProvider, providers } = await buildModelsProviderData(params.cfg);
+    const isTelegram = params.surface === "telegram";
+    // Provider list (no provider specified)
+    if (!provider) {
+        // For Telegram: show buttons if there are providers
+        if (isTelegram && providers.length > 0) {
+            const providerInfos = providers.map((p) => ({
+                id: p,
+                count: byProvider.get(p)?.size ?? 0,
+            }));
+            const buttons = buildProviderKeyboard(providerInfos);
+            const text = "Select a provider:";
+            return {
+                text,
+                channelData: { telegram: { buttons } },
+            };
+        }
+        // Text fallback for non-Telegram surfaces
+        const lines = [
+            "Providers:",
+            ...providers.map((p) => formatProviderLine({ provider: p, count: byProvider.get(p)?.size ?? 0 })),
+            "",
+            "Use: /models <provider>",
+            "Switch: /model <provider/model>",
+        ];
+        return { text: lines.join("\n") };
+    }
+    if (!byProvider.has(provider)) {
+        const lines = [
+            `Unknown provider: ${provider}`,
+            "",
+            "Available providers:",
+            ...providers.map((p) => `- ${p}`),
+            "",
+            "Use: /models <provider>",
+        ];
+        return { text: lines.join("\n") };
+    }
+    const models = [...(byProvider.get(provider) ?? new Set())].toSorted();
+    const total = models.length;
+    const providerLabel = resolveProviderLabel({
+        provider,
+        cfg: params.cfg,
+        agentDir: params.agentDir,
+        sessionEntry: params.sessionEntry,
+    });
+    if (total === 0) {
+        const lines = [
+            `Models (${providerLabel}) \u2014 none`,
+            "",
+            "Browse: /models",
+            "Switch: /model <provider/model>",
+        ];
+        return { text: lines.join("\n") };
+    }
+    // For Telegram: use button-based model list with inline keyboard pagination
+    if (isTelegram) {
+        const telegramPageSize = getModelsPageSize();
+        const totalPages = calculateTotalPages(total, telegramPageSize);
+        const safePage = Math.max(1, Math.min(page, totalPages));
+        const buttons = buildModelsKeyboard({
+            provider,
+            models,
+            currentModel: params.currentModel,
+            currentPage: safePage,
+            totalPages,
+            pageSize: telegramPageSize,
+        });
+        const text = formatModelsAvailableHeader({
+            provider,
+            total,
+            cfg: params.cfg,
+            agentDir: params.agentDir,
+            sessionEntry: params.sessionEntry,
+        });
+        return {
+            text,
+            channelData: { telegram: { buttons } },
+        };
+    }
+    // Text fallback for non-Telegram surfaces
+    const effectivePageSize = all ? total : pageSize;
+    const pageCount = effectivePageSize > 0 ? Math.ceil(total / effectivePageSize) : 1;
+    const safePage = all ? 1 : Math.max(1, Math.min(page, pageCount));
+    if (!all && page !== safePage) {
+        const lines = [
+            `Page out of range: ${page} (valid: 1-${pageCount})`,
+            "",
+            `Try: /models ${provider} ${safePage}`,
+            `All: /models ${provider} all`,
+        ];
+        return { text: lines.join("\n") };
+    }
+    const startIndex = (safePage - 1) * effectivePageSize;
+    const endIndexExclusive = Math.min(total, startIndex + effectivePageSize);
+    const pageModels = models.slice(startIndex, endIndexExclusive);
+    const header = `Models (${providerLabel}) \u2014 showing ${startIndex + 1}-${endIndexExclusive} of ${total} (page ${safePage}/${pageCount})`;
+    const lines = [header];
+    for (const id of pageModels) {
+        lines.push(`- ${provider}/${id}`);
+    }
+    lines.push("", "Switch: /model <provider/model>");
+    if (!all && safePage < pageCount) {
+        lines.push(`More: /models ${provider} ${safePage + 1}`);
+    }
+    if (!all) {
+        lines.push(`All: /models ${provider} all`);
+    }
+    const payload = { text: lines.join("\n") };
+    return payload;
+}
+export const handleModelsCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const modelsAgentId = params.agentId ??
+        resolveSessionAgentId({
+            sessionKey: params.sessionKey,
+            config: params.cfg,
+        });
+    const modelsAgentDir = resolveAgentDir(params.cfg, modelsAgentId);
+    const reply = await resolveModelsCommandReply({
+        cfg: params.cfg,
+        commandBodyNormalized: params.command.commandBodyNormalized,
+        surface: params.ctx.Surface,
+        currentModel: params.model ? `${params.provider}/${params.model}` : undefined,
+        agentDir: modelsAgentDir,
+        sessionEntry: params.sessionEntry,
+    });
+    if (!reply) {
+        return null;
+    }
+    return { reply, shouldContinue: false };
+};

package/dist/auto-reply/auto-reply/reply/commands-plugin.js

@@ -0,0 +1,35 @@
+/**
+ * Plugin Command Handler
+ *
+ * Handles commands registered by plugins, bypassing the LLM agent.
+ * This handler is called before built-in command handlers.
+ */
+import { matchPluginCommand, executePluginCommand } from "../../plugins/commands.js";
+/**
+ * Handle plugin-registered commands.
+ * Returns a result if a plugin command was matched and executed,
+ * or null to continue to the next handler.
+ */
+export const handlePluginCommand = async (params, allowTextCommands) => {
+    const { command, cfg } = params;
+    if (!allowTextCommands)
+        return null;
+    // Try to match a plugin command
+    const match = matchPluginCommand(command.commandBodyNormalized);
+    if (!match)
+        return null;
+    // Execute the plugin command (always returns a result)
+    const result = await executePluginCommand({
+        command: match.command,
+        args: match.args,
+        senderId: command.senderId,
+        channel: command.channel,
+        isAuthorizedSender: command.isAuthorizedSender,
+        commandBody: command.commandBodyNormalized,
+        config: cfg,
+    });
+    return {
+        shouldContinue: false,
+        reply: result,
+    };
+};

package/dist/auto-reply/auto-reply/reply/commands-ptt.js

@@ -0,0 +1,171 @@
+import { callGateway, randomIdempotencyKey } from "../../gateway/call.js";
+import { logVerbose } from "../../globals.js";
+const PTT_COMMANDS = {
+    start: "talk.ptt.start",
+    stop: "talk.ptt.stop",
+    once: "talk.ptt.once",
+    cancel: "talk.ptt.cancel",
+};
+function normalizeNodeKey(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+}
+function isIOSNode(node) {
+    const platform = node.platform?.toLowerCase() ?? "";
+    const family = node.deviceFamily?.toLowerCase() ?? "";
+    return (platform.startsWith("ios") ||
+        family.includes("iphone") ||
+        family.includes("ipad") ||
+        family.includes("ios"));
+}
+async function loadNodes(cfg) {
+    try {
+        const res = await callGateway({
+            method: "node.list",
+            params: {},
+            config: cfg,
+        });
+        return Array.isArray(res.nodes) ? res.nodes : [];
+    }
+    catch {
+        const res = await callGateway({
+            method: "node.pair.list",
+            params: {},
+            config: cfg,
+        });
+        return Array.isArray(res.paired) ? res.paired : [];
+    }
+}
+function describeNodes(nodes) {
+    return nodes
+        .map((node) => node.displayName || node.remoteIp || node.nodeId)
+        .filter(Boolean)
+        .join(", ");
+}
+function resolveNodeId(nodes, query) {
+    const trimmed = String(query ?? "").trim();
+    if (trimmed) {
+        const qNorm = normalizeNodeKey(trimmed);
+        const matches = nodes.filter((node) => {
+            if (node.nodeId === trimmed) {
+                return true;
+            }
+            if (typeof node.remoteIp === "string" && node.remoteIp === trimmed) {
+                return true;
+            }
+            const name = typeof node.displayName === "string" ? node.displayName : "";
+            if (name && normalizeNodeKey(name) === qNorm) {
+                return true;
+            }
+            if (trimmed.length >= 6 && node.nodeId.startsWith(trimmed)) {
+                return true;
+            }
+            return false;
+        });
+        if (matches.length === 1) {
+            return matches[0].nodeId;
+        }
+        const known = describeNodes(nodes);
+        if (matches.length === 0) {
+            throw new Error(`unknown node: ${trimmed}${known ? ` (known: ${known})` : ""}`);
+        }
+        throw new Error(`ambiguous node: ${trimmed} (matches: ${matches
+            .map((node) => node.displayName || node.remoteIp || node.nodeId)
+            .join(", ")})`);
+    }
+    const iosNodes = nodes.filter(isIOSNode);
+    const iosConnected = iosNodes.filter((node) => node.connected);
+    const iosCandidates = iosConnected.length > 0 ? iosConnected : iosNodes;
+    if (iosCandidates.length === 1) {
+        return iosCandidates[0].nodeId;
+    }
+    if (iosCandidates.length > 1) {
+        throw new Error(`multiple iOS nodes found (${describeNodes(iosCandidates)}); specify node=<id>`);
+    }
+    const connected = nodes.filter((node) => node.connected);
+    const fallback = connected.length > 0 ? connected : nodes;
+    if (fallback.length === 1) {
+        return fallback[0].nodeId;
+    }
+    const known = describeNodes(nodes);
+    throw new Error(`node required${known ? ` (known: ${known})` : ""}`);
+}
+function parsePTTArgs(commandBody) {
+    const tokens = commandBody.trim().split(/\s+/).slice(1);
+    let action;
+    let node;
+    for (const token of tokens) {
+        if (!token) {
+            continue;
+        }
+        if (token.toLowerCase().startsWith("node=")) {
+            node = token.slice("node=".length);
+            continue;
+        }
+        if (!action) {
+            action = token;
+        }
+    }
+    return { action, node };
+}
+function buildPTTHelpText() {
+    return [
+        "Usage: /ptt <start|stop|once|cancel> [node=<id>]",
+        "Example: /ptt once node=iphone",
+    ].join("\n");
+}
+export const handlePTTCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const { command, cfg } = params;
+    const normalized = command.commandBodyNormalized.trim();
+    if (!normalized.startsWith("/ptt")) {
+        return null;
+    }
+    if (!command.isAuthorizedSender) {
+        logVerbose(`Ignoring /ptt from unauthorized sender: ${command.senderId || "<unknown>"}`);
+        return { shouldContinue: false, reply: { text: "PTT requires an authorized sender." } };
+    }
+    const parsed = parsePTTArgs(normalized);
+    const actionKey = parsed.action?.trim().toLowerCase() ?? "";
+    const commandId = PTT_COMMANDS[actionKey];
+    if (!commandId) {
+        return { shouldContinue: false, reply: { text: buildPTTHelpText() } };
+    }
+    try {
+        const nodes = await loadNodes(cfg);
+        const nodeId = resolveNodeId(nodes, parsed.node);
+        const invokeParams = {
+            nodeId,
+            command: commandId,
+            params: {},
+            idempotencyKey: randomIdempotencyKey(),
+            timeoutMs: 15_000,
+        };
+        const res = await callGateway({
+            method: "node.invoke",
+            params: invokeParams,
+            config: cfg,
+        });
+        const payload = res.payload && typeof res.payload === "object" ? res.payload : {};
+        const lines = [`PTT ${actionKey} → ${nodeId}`];
+        if (typeof payload.status === "string") {
+            lines.push(`status: ${payload.status}`);
+        }
+        if (typeof payload.captureId === "string") {
+            lines.push(`captureId: ${payload.captureId}`);
+        }
+        if (typeof payload.transcript === "string" && payload.transcript.trim()) {
+            lines.push(`transcript: ${payload.transcript}`);
+        }
+        return { shouldContinue: false, reply: { text: lines.join("\n") } };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { shouldContinue: false, reply: { text: `PTT failed: ${message}` } };
+    }
+};