@nordbyte/nordrelay 0.6.0 → 0.8.0

package/dist/channel-command-service.js

@@ -1,11 +1,15 @@
 import { listAgentAdapterDescriptors } from "./agent-adapter.js";
 import { enabledAgents } from "./agent-factory.js";
+import { formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
 import { logTailRequests, parseLogsCommand, renderAgentsAction, renderChannelsAction, renderLogTailsAction, } from "./channel-actions.js";
 import { listChannelDescriptors } from "./channel-adapter.js";
+import { friendlyErrorText } from "./error-messages.js";
 import { escapeHTML } from "./format.js";
 import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, } from "./operations.js";
-import { formatCliPathHTML, formatCliPathPlain, renderActivityTimeline, renderAuditEvents, renderProgressHTML, renderProgressPlain, renderVersionCheckHTML, renderVersionCheckPlain, } from "./bot-rendering.js";
+import { PeerStore } from "./peer-store.js";
+import { formatCliPathHTML, formatCliPathPlain, renderActivityTimeline, renderAuditEvents, renderProgressHTML, renderProgressPlain, parseToggle, renderVersionCheckHTML, renderVersionCheckPlain, } from "./bot-rendering.js";
 import { renderSessionInfoHTML, renderSessionInfoPlain } from "./session-format.js";
+import { getAvailableBackends } from "./voice.js";
 export class ChannelCommandService {
     config;
     constructor(config) {
@@ -17,6 +21,61 @@ export class ChannelCommandService {
     renderAgents(agentIds = enabledAgents(this.config)) {
         return renderAgentsAction(listAgentAdapterDescriptors(), agentIds);
     }
+    renderPeers() {
+        const peers = new PeerStore().listPublic();
+        if (peers.length === 0) {
+            return {
+                plain: "No NordRelay peers configured.",
+                html: "No NordRelay peers configured.",
+            };
+        }
+        const plain = peers.map((peer) => [
+            `${peer.name} (${peer.id}) ${peer.enabled ? "enabled" : "disabled"}`,
+            `URL: ${peer.url ?? "-"}`,
+            `Node: ${peer.nodeId}`,
+            `Scopes: ${peer.scopes.join(", ") || "-"}`,
+            peer.remoteStatus || peer.lastLatencyMs !== undefined ? `Health: ${peer.remoteStatus ?? "seen"}${peer.lastLatencyMs !== undefined ? ` / ${peer.lastLatencyMs}ms` : ""}${peer.remoteVersion ? ` / v${peer.remoteVersion}` : ""}` : "",
+            Object.keys(peer.workspaceAliases ?? {}).length > 0 ? `Aliases: ${Object.entries(peer.workspaceAliases).map(([alias, workspace]) => `${alias}=${workspace}`).join(", ")}` : "",
+            peer.lastSeenAt ? `Last seen: ${peer.lastSeenAt}` : "",
+            peer.lastError ? `Last error: ${peer.lastError}` : "",
+        ].filter(Boolean).join("\n")).join("\n\n");
+        const html = peers.map((peer) => [
+            `<b>${escapeHTML(peer.name)} (${escapeHTML(peer.id)})</b> <code>${peer.enabled ? "enabled" : "disabled"}</code>`,
+            `<b>URL:</b> <code>${escapeHTML(peer.url ?? "-")}</code>`,
+            `<b>Node:</b> <code>${escapeHTML(peer.nodeId)}</code>`,
+            `<b>Scopes:</b> <code>${escapeHTML(peer.scopes.join(", ") || "-")}</code>`,
+            peer.remoteStatus || peer.lastLatencyMs !== undefined ? `<b>Health:</b> <code>${escapeHTML(`${peer.remoteStatus ?? "seen"}${peer.lastLatencyMs !== undefined ? ` / ${peer.lastLatencyMs}ms` : ""}${peer.remoteVersion ? ` / v${peer.remoteVersion}` : ""}`)}</code>` : "",
+            Object.keys(peer.workspaceAliases ?? {}).length > 0 ? `<b>Aliases:</b> <code>${escapeHTML(Object.entries(peer.workspaceAliases).map(([alias, workspace]) => `${alias}=${workspace}`).join(", "))}</code>` : "",
+            peer.lastSeenAt ? `<b>Last seen:</b> <code>${escapeHTML(peer.lastSeenAt)}</code>` : "",
+            peer.lastError ? `<b>Last error:</b> <code>${escapeHTML(peer.lastError)}</code>` : "",
+        ].filter(Boolean).join("\n")).join("\n\n");
+        return { plain, html };
+    }
+    renderTargetPreference(options) {
+        const argument = options.argument.trim();
+        const peers = new PeerStore().listPublic().filter((peer) => peer.enabled && peer.url);
+        if (argument) {
+            const normalized = argument.toLowerCase();
+            if (normalized === "local") {
+                options.preferencesStore.update(options.contextKey, { targetPeerId: null });
+            }
+            else {
+                const peer = peers.find((candidate) => candidate.id === argument || candidate.name.toLowerCase() === normalized || candidate.nodeId === argument);
+                if (!peer) {
+                    return usageResponse("Unknown peer target. Use /target local or /target <peer-id>.");
+                }
+                options.preferencesStore.update(options.contextKey, { targetPeerId: peer.id });
+            }
+        }
+        const current = options.preferencesStore.get(options.contextKey).targetPeerId;
+        const currentPeer = current ? peers.find((peer) => peer.id === current) : null;
+        const target = currentPeer ? `${currentPeer.name} (${currentPeer.id})` : "local";
+        const available = peers.map((peer) => `${peer.id} ${peer.name}`).join("\n") || "No enabled outbound peers.";
+        return {
+            plain: [`Target: ${target}`, "", "Available peers:", available].join("\n"),
+            html: [`<b>Target:</b> <code>${escapeHTML(target)}</code>`, "", "<b>Available peers:</b>", `<code>${escapeHTML(available)}</code>`].join("\n"),
+        };
+    }
     async renderLogs(argument) {
         const logRequest = parseLogsCommand(argument);
         const logs = await Promise.all(logTailRequests(logRequest.target).map(async (request) => ({
@@ -101,6 +160,142 @@ export class ChannelCommandService {
     renderAudit(events) {
         return renderAuditEvents(events);
     }
+    renderMirrorPreference(options) {
+        if (options.cliMirrorSupported === false) {
+            const text = `CLI mirroring is not supported for ${options.agentLabel ?? "this agent"} yet.`;
+            return { plain: text, html: escapeHTML(text) };
+        }
+        const argument = options.argument.trim();
+        if (argument) {
+            const normalized = argument.toLowerCase();
+            if (!["off", "status", "final", "full"].includes(normalized)) {
+                return usageResponse("Usage: /mirror [off|status|final|full]");
+            }
+            options.preferencesStore.update(options.contextKey, {
+                mirrorMode: parseMirrorMode(argument, this.defaultMirrorMode(options.source)),
+            });
+        }
+        const mode = this.effectiveMirrorMode(options.source, options.contextKey, options.preferencesStore);
+        const minInterval = options.source === "telegram"
+            ? this.config.telegramMirrorMinUpdateMs
+            : options.source === "discord"
+                ? this.config.discordMirrorMinUpdateMs
+                : this.config.slackMirrorMinUpdateMs;
+        return {
+            plain: [
+                `CLI mirroring: ${mode}`,
+                `Minimum update interval: ${minInterval} ms`,
+                "Modes: off, status, final, full",
+            ].join("\n"),
+            html: [
+                `<b>CLI mirroring:</b> <code>${escapeHTML(mode)}</code>`,
+                `<b>Minimum update interval:</b> <code>${minInterval} ms</code>`,
+                "<b>Modes:</b> <code>off</code>, <code>status</code>, <code>final</code>, <code>full</code>",
+            ].join("\n"),
+        };
+    }
+    renderNotifyPreference(options) {
+        const argument = options.argument.trim();
+        if (argument) {
+            const quietMatch = argument.match(/^quiet\s+(.+)$/i);
+            if (quietMatch) {
+                try {
+                    const quietHours = quietMatch[1].toLowerCase() === "off" ? null : parseQuietHours(quietMatch[1]);
+                    options.preferencesStore.update(options.contextKey, { quietHours });
+                }
+                catch (error) {
+                    const text = `Invalid quiet hours: ${friendlyErrorText(error)}`;
+                    return { plain: text, html: escapeHTML(text) };
+                }
+            }
+            else {
+                const normalized = argument.toLowerCase();
+                if (!["off", "minimal", "all"].includes(normalized)) {
+                    return usageResponse("Usage: /notify [off|minimal|all] or /notify quiet HH-HH");
+                }
+                options.preferencesStore.update(options.contextKey, {
+                    notifyMode: parseNotifyMode(argument, this.defaultNotifyMode(options.source)),
+                });
+            }
+        }
+        const mode = this.effectiveNotifyMode(options.source, options.contextKey, options.preferencesStore);
+        const quietHours = this.effectiveQuietHours(options.source, options.contextKey, options.preferencesStore);
+        return {
+            plain: [
+                `Notifications: ${mode}`,
+                `Quiet hours: ${formatQuietHours(quietHours)}`,
+                `Currently quiet: ${isQuietNow(quietHours) ? "yes" : "no"}`,
+            ].join("\n"),
+            html: [
+                `<b>Notifications:</b> <code>${escapeHTML(mode)}</code>`,
+                `<b>Quiet hours:</b> <code>${escapeHTML(formatQuietHours(quietHours))}</code>`,
+                `<b>Currently quiet:</b> <code>${isQuietNow(quietHours) ? "yes" : "no"}</code>`,
+            ].join("\n"),
+        };
+    }
+    async renderVoicePreference(options) {
+        const argument = options.argument.trim();
+        if (argument) {
+            const parts = argument.split(/\s+/);
+            const key = parts[0]?.toLowerCase();
+            const value = parts.slice(1).join(" ").trim();
+            if (key === "backend" && value) {
+                const normalized = value.toLowerCase();
+                if (!["auto", "parakeet", "faster-whisper", "openai"].includes(normalized)) {
+                    return usageResponse("Usage: /voice backend auto|parakeet|faster-whisper|openai");
+                }
+                options.preferencesStore.update(options.contextKey, { voiceBackend: parseVoiceBackendPreference(value) });
+            }
+            else if (key === "language") {
+                options.preferencesStore.update(options.contextKey, { voiceLanguage: value && value.toLowerCase() !== "auto" ? value : null });
+            }
+            else if (key === "transcribe_only" || key === "transcribe-only") {
+                const enabled = parseToggle(value);
+                if (enabled === undefined) {
+                    return usageResponse("Usage: /voice transcribe_only on|off");
+                }
+                options.preferencesStore.update(options.contextKey, { voiceTranscribeOnly: enabled });
+            }
+            else {
+                return usageResponse("Usage: /voice, /voice backend auto|parakeet|faster-whisper|openai, /voice language auto|language-code, /voice transcribe_only on|off");
+            }
+        }
+        const backends = await getAvailableBackends().catch(() => []);
+        if (backends.length === 0) {
+            const plain = [
+                "Voice transcription is not available.",
+                "",
+                "Install faster-whisper + ffmpeg, install parakeet-coreml on macOS Apple Silicon, or set OPENAI_API_KEY.",
+                "Cloud transcription uses OPENAI_API_KEY, not CODEX_API_KEY.",
+            ].join("\n");
+            const html = [
+                "<b>Voice transcription is not available.</b>",
+                "",
+                "Install <code>faster-whisper</code> + ffmpeg, install <code>parakeet-coreml</code> on macOS Apple Silicon, or set <code>OPENAI_API_KEY</code>.",
+                "<i>Cloud transcription uses OPENAI_API_KEY, not CODEX_API_KEY.</i>",
+            ].join("\n");
+            return { plain, html };
+        }
+        const prefs = options.preferencesStore.get(options.contextKey);
+        const backendPreference = prefs.voiceBackend ?? this.config.voicePreferredBackend;
+        const language = prefs.voiceLanguage === undefined ? this.config.voiceDefaultLanguage ?? null : prefs.voiceLanguage;
+        const transcribeOnly = prefs.voiceTranscribeOnly ?? this.config.voiceTranscribeOnly;
+        const joined = backends.join(" + ");
+        return {
+            plain: [
+                `Voice backends: ${joined}`,
+                `Preferred backend: ${backendPreference}`,
+                `Language: ${language ?? "auto"}`,
+                `Transcribe only: ${transcribeOnly ? "on" : "off"}`,
+            ].join("\n"),
+            html: [
+                `<b>Voice backends:</b> <code>${escapeHTML(joined)}</code>`,
+                `<b>Preferred backend:</b> <code>${escapeHTML(backendPreference)}</code>`,
+                `<b>Language:</b> <code>${escapeHTML(language ?? "auto")}</code>`,
+                `<b>Transcribe only:</b> <code>${transcribeOnly ? "on" : "off"}</code>`,
+            ].join("\n"),
+        };
+    }
     renderWorkspaces(info, workspaces) {
         const unique = [...new Set(workspaces)].filter(Boolean);
         const rows = unique.length > 0
@@ -142,6 +337,37 @@ export class ChannelCommandService {
             ].join("\n"),
         };
     }
+    defaultMirrorMode(source) {
+        return source === "telegram"
+            ? this.config.telegramMirrorMode
+            : source === "discord"
+                ? this.config.discordMirrorMode
+                : this.config.slackMirrorMode;
+    }
+    defaultNotifyMode(source) {
+        return source === "telegram"
+            ? this.config.telegramNotifyMode
+            : source === "discord"
+                ? this.config.discordNotifyMode
+                : this.config.slackNotifyMode;
+    }
+    defaultQuietHours(source) {
+        return source === "telegram"
+            ? this.config.telegramQuietHours
+            : source === "discord"
+                ? this.config.discordQuietHours
+                : this.config.slackQuietHours;
+    }
+    effectiveMirrorMode(source, contextKey, preferencesStore) {
+        return preferencesStore.get(contextKey).mirrorMode ?? this.defaultMirrorMode(source);
+    }
+    effectiveNotifyMode(source, contextKey, preferencesStore) {
+        return preferencesStore.get(contextKey).notifyMode ?? this.defaultNotifyMode(source);
+    }
+    effectiveQuietHours(source, contextKey, preferencesStore) {
+        const prefs = preferencesStore.get(contextKey);
+        return prefs.quietHours === undefined ? this.defaultQuietHours(source) : prefs.quietHours;
+    }
 }
 export function cliPathOptions(config) {
     return {
@@ -154,3 +380,6 @@ export function cliPathOptions(config) {
 function shellEscape(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function usageResponse(text) {
+    return { plain: text, html: escapeHTML(text) };
+}

package/dist/channel-mirror-registry.js

@@ -0,0 +1,84 @@
+import { channelIdForContextKey } from "./context-key.js";
+export class ChannelMirrorRegistry {
+    config;
+    promptStore;
+    states = new Map();
+    constructor(config, promptStore) {
+        this.config = config;
+        this.promptStore = promptStore;
+    }
+    activeMirrorsForThread(agentId, threadId, knownContexts, preferences) {
+        const mirrors = [];
+        const seen = new Set();
+        for (const meta of knownContexts) {
+            const metaAgentId = meta.agentId ?? this.config.defaultAgent;
+            if (meta.threadId !== threadId || metaAgentId !== agentId) {
+                continue;
+            }
+            const source = activeSessionSourceForContextKey(meta.contextKey);
+            if (!isMirrorChannelSource(source) || seen.has(meta.contextKey)) {
+                continue;
+            }
+            const mode = this.effectiveMirrorMode(meta.contextKey, source, preferences);
+            if (mode === "off") {
+                this.states.delete(this.stateKey(source, meta.contextKey, agentId, threadId));
+                continue;
+            }
+            seen.add(meta.contextKey);
+            const mirror = {
+                source,
+                contextKey: meta.contextKey,
+                mode,
+                queueLength: this.promptStore.list(meta.contextKey).length,
+                queuePaused: this.promptStore.isPaused(meta.contextKey),
+            };
+            mirrors.push(mirror);
+            this.states.set(this.stateKey(source, meta.contextKey, agentId, threadId), {
+                ...mirror,
+                agentId,
+                threadId,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        return mirrors;
+    }
+    queueLengthForExternalSource(sourceContextKey, mirrors) {
+        return mirrors.reduce((sum, mirror) => sum + mirror.queueLength, this.promptStore.list(sourceContextKey).length);
+    }
+    queuePausedForExternalSource(sourceContextKey, mirrors) {
+        return mirrors.some((mirror) => mirror.queuePaused) || this.promptStore.isPaused(sourceContextKey);
+    }
+    effectiveMirrorMode(contextKey, source, preferences) {
+        const configured = source === "telegram"
+            ? this.config.telegramMirrorMode
+            : source === "discord"
+                ? this.config.discordMirrorMode
+                : this.config.slackMirrorMode;
+        return preferences.get(contextKey).mirrorMode ?? configured;
+    }
+    snapshot() {
+        return [...this.states.values()].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+    }
+    stateKey(source, contextKey, agentId, threadId) {
+        return `${source}:${contextKey}:${agentId}:${threadId}`;
+    }
+}
+export function activeSessionSourceForContextKey(contextKey) {
+    const channelId = channelIdForContextKey(contextKey);
+    if (channelId === "telegram") {
+        return "telegram";
+    }
+    if (channelId === "discord") {
+        return "discord";
+    }
+    if (channelId === "slack") {
+        return "slack";
+    }
+    if (channelId === "web") {
+        return "web";
+    }
+    return "cli";
+}
+export function isMirrorChannelSource(source) {
+    return source === "telegram" || source === "discord" || source === "slack";
+}

package/dist/channel-peer-prompt.js

@@ -0,0 +1,95 @@
+import { friendlyErrorText } from "./error-messages.js";
+import { RemoteRelayClient } from "./peer-client.js";
+import { peerPromptProxyPayload } from "./remote-prompt.js";
+export async function runChannelPeerPrompt(options) {
+    if (!options.targetPeerId) {
+        return false;
+    }
+    const client = options.remoteClient ?? new RemoteRelayClient();
+    let responseMessageId;
+    let accumulated = "";
+    let lastEditAt = 0;
+    let completed = false;
+    let closeSubscription = () => { };
+    const typing = setInterval(() => {
+        void options.sendTyping().catch(() => { });
+    }, options.typingIntervalMs);
+    typing.unref?.();
+    void options.sendTyping().catch(() => { });
+    const flush = async (force = false) => {
+        if (!accumulated.trim()) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - lastEditAt < options.editMinIntervalMs) {
+            return;
+        }
+        if (responseMessageId === undefined) {
+            responseMessageId = await options.sendResponse(accumulated);
+        }
+        else {
+            await options.editResponse(responseMessageId, accumulated);
+        }
+        lastEditAt = now;
+    };
+    const done = new Promise((resolve) => {
+        const timeout = setTimeout(resolve, 30 * 60 * 1000);
+        timeout.unref?.();
+        let subscription;
+        const finish = () => {
+            clearTimeout(timeout);
+            subscription?.close();
+            resolve();
+        };
+        subscription = client.subscribe(options.targetPeerId, (event) => {
+            if (event.type === "turn_start") {
+                void options.sendTurnStart(event.prompt).catch(() => { });
+            }
+            else if (event.type === "text_delta") {
+                accumulated += event.delta;
+                void flush(false).catch(() => { });
+            }
+            else if (event.type === "tool_start") {
+                void options.sendToolStart(event.toolName).catch(() => { });
+            }
+            else if (event.type === "turn_complete") {
+                completed = true;
+                finish();
+            }
+            else if (event.type === "turn_error") {
+                accumulated += `\n\nError: ${event.error}`;
+                completed = true;
+                finish();
+            }
+        }, (error) => {
+            accumulated += `\n\nRemote event stream failed: ${error.message}`;
+            finish();
+        }, options.contextKey);
+        closeSubscription = () => subscription?.close();
+    });
+    try {
+        const result = await client.webProxy(options.targetPeerId, await peerPromptProxyPayload(options.prompt), options.prompt.activityActor, options.contextKey);
+        if (isQueuedRemoteResult(result)) {
+            closeSubscription();
+            await options.sendQueued(String(result.queueId ?? ""));
+            return true;
+        }
+        await done;
+        await flush(true);
+        if (!accumulated.trim() && completed) {
+            await options.sendCompleted();
+        }
+        return true;
+    }
+    catch (error) {
+        await options.sendFailure(friendlyErrorText(error));
+        return true;
+    }
+    finally {
+        clearInterval(typing);
+        closeSubscription();
+    }
+}
+function isQueuedRemoteResult(value) {
+    return Boolean(value && typeof value === "object" && "queued" in value && value.queued);
+}

package/dist/channel-prompt-engine.js

@@ -0,0 +1,177 @@
+import { createChannelTurnLifecycle, createChannelTypingLoop } from "./channel-turn-lifecycle.js";
+export function createChannelPromptEngine(options) {
+    const lifecycle = createChannelTurnLifecycle(options.promptDescription);
+    const { progress, startedAt, turnId } = lifecycle;
+    let accumulated = "";
+    let responseMessageId;
+    let planMessageId;
+    let flushTimer;
+    const typingLoop = createChannelTypingLoop({
+        intervalMs: options.typingIntervalMs,
+        sendTyping: () => options.runtime.sendTyping(options.context),
+    });
+    let lastEditAt = 0;
+    let running = false;
+    let finalized = false;
+    const buttons = options.abortAction
+        ? [[{ label: "Abort", action: options.abortAction }]]
+        : undefined;
+    const clearFlushTimer = () => {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = undefined;
+        }
+    };
+    const ensureResponse = async () => {
+        if (responseMessageId) {
+            return;
+        }
+        const preview = options.trimMessage(accumulated || "Working...");
+        const sent = await options.runtime.sendMessage(options.context, {
+            text: preview,
+            fallbackText: preview,
+            buttons,
+        });
+        responseMessageId = sent.messageId;
+        options.onResponseMessage?.(responseMessageId);
+        lastEditAt = Date.now();
+    };
+    const flushResponse = async (force = false) => {
+        if (!accumulated.trim()) {
+            return;
+        }
+        await ensureResponse();
+        if (!responseMessageId) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - lastEditAt < options.editDebounceMs) {
+            return;
+        }
+        const rendered = options.trimMessage(accumulated);
+        await options.runtime.editMessage(options.context, responseMessageId, {
+            text: rendered,
+            fallbackText: rendered,
+            buttons,
+        });
+        lastEditAt = Date.now();
+    };
+    const scheduleFlush = () => {
+        if (flushTimer || !running) {
+            return;
+        }
+        const delay = Math.max(0, options.editDebounceMs - (Date.now() - lastEditAt));
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            void flushResponse().catch((error) => console.error(`Failed to edit ${options.logPrefix} response:`, error));
+        }, delay);
+        flushTimer.unref?.();
+    };
+    const stop = () => {
+        running = false;
+        typingLoop.stop();
+        clearFlushTimer();
+    };
+    const finalize = async () => {
+        if (finalized) {
+            return;
+        }
+        finalized = true;
+        lifecycle.recordCompleted();
+        stop();
+        const finalText = accumulated.trim() || "Done.";
+        const chunks = options.splitMessage(finalText);
+        if (responseMessageId) {
+            const [first, ...rest] = chunks;
+            await options.runtime.editMessage(options.context, responseMessageId, {
+                text: first ?? "Done.",
+                fallbackText: first ?? "Done.",
+            });
+            for (const chunk of rest) {
+                await options.runtime.sendMessage(options.context, { text: chunk, fallbackText: chunk });
+            }
+            return;
+        }
+        for (const chunk of chunks) {
+            await options.runtime.sendMessage(options.context, { text: chunk, fallbackText: chunk });
+        }
+    };
+    const fail = async (text) => {
+        finalized = true;
+        lifecycle.recordFailed(text);
+        stop();
+        const rendered = options.trimMessage(text);
+        if (responseMessageId) {
+            await options.runtime.editMessage(options.context, responseMessageId, {
+                text: rendered,
+                fallbackText: rendered,
+            }).catch(() => { });
+            return;
+        }
+        await options.runtime.sendMessage(options.context, {
+            text: rendered,
+            fallbackText: rendered,
+        }).catch(() => { });
+    };
+    const callbacks = {
+        onTextDelta: (delta) => {
+            accumulated += delta;
+            lifecycle.recordTextDelta(delta.length);
+            void ensureResponse()
+                .then(() => scheduleFlush())
+                .catch((error) => console.error(`Failed to send ${options.logPrefix} response:`, error));
+        },
+        onToolStart: (toolName) => {
+            lifecycle.recordToolStart(toolName);
+            options.onToolStart?.(toolName);
+            if (options.toolVerbosity === "all") {
+                const text = `Tool started: ${toolName}`;
+                void options.runtime.sendMessage(options.context, { text, fallbackText: text }).catch(() => { });
+            }
+        },
+        onToolUpdate: () => {
+            lifecycle.recordToolUpdate();
+        },
+        onToolEnd: (_toolCallId, isError) => {
+            lifecycle.recordToolEnd();
+            options.onToolEnd?.(isError);
+        },
+        onTodoUpdate: (items) => {
+            lifecycle.touch();
+            const text = [
+                "Plan:",
+                ...items.map((item) => `${item.completed ? "[x]" : "[ ]"} ${item.text}`),
+            ].join("\n");
+            if (!planMessageId) {
+                void options.runtime.sendMessage(options.context, { text, fallbackText: text }).then((result) => {
+                    planMessageId = result.messageId;
+                }).catch(() => { });
+            }
+            else {
+                void options.runtime.editMessage(options.context, planMessageId, { text, fallbackText: text }).catch(() => { });
+            }
+        },
+        onTurnComplete: () => { },
+        onAgentEnd: () => {
+            lifecycle.recordCompleted();
+            void finalize().catch((error) => console.error(`Failed to finalize ${options.logPrefix} response:`, error));
+        },
+    };
+    return {
+        turnId,
+        startedAt,
+        progress,
+        callbacks,
+        accumulatedText: () => accumulated,
+        start: () => {
+            if (running) {
+                return;
+            }
+            running = true;
+            typingLoop.start();
+        },
+        stop,
+        finalize,
+        fail,
+    };
+}

package/dist/channel-runtime.js

@@ -1,13 +1,19 @@
 export class ChannelCommandRouter {
     handlers = new Map();
     command(name, handler) {
-        const normalized = normalizeCommandName(name);
+        const normalized = normalizeChannelCommandName(name);
         if (!normalized) {
             throw new Error("Channel command name is required.");
         }
         this.handlers.set(normalized, handler);
         return this;
     }
+    commands(names, handler) {
+        for (const name of names) {
+            this.command(name, handler);
+        }
+        return this;
+    }
     async dispatch(message) {
         const parsed = parseChannelCommand(message.text ?? "");
         if (!parsed) {
@@ -36,13 +42,14 @@ export async function deliverChannelAction(runtime, context, response) {
         buttons: response.buttons,
     });
 }
-export function parseChannelCommand(text) {
-    const match = text.trimStart().match(/^\/([a-zA-Z0-9_-]+)(?:@\w+)?(?:\s+([\s\S]*))?$/);
+export function parseChannelCommand(text, options = {}) {
+    const mention = options.allowBotMention === false ? "" : "(?:@\\w+)?";
+    const match = text.trimStart().match(new RegExp(`^/([a-zA-Z0-9_-]+)${mention}(?:\\s+([\\s\\S]*))?$`));
     if (!match?.[1]) {
         return null;
     }
     return {
-        command: normalizeCommandName(match[1]),
+        command: normalizeChannelCommandName(match[1]),
         argument: match[2]?.trim() ?? "",
     };
 }
@@ -84,6 +91,6 @@ export class InMemoryChannelRuntime {
         return { messageId };
     }
 }
-function normalizeCommandName(name) {
+export function normalizeChannelCommandName(name) {
     return name.trim().replace(/^\//, "").toLowerCase();
 }