@theowlops/boombot 0.0.0-stage → 1.1.0

package/dist/node_modules/@boombot/channels/transports/telegram/transport.d.ts

@@ -0,0 +1,75 @@
+import type { ChannelKind } from '@boombot/protocol';
+import { TURN_DONE_EVENT, type ChannelLogger, type ChannelRuntimeStatus, type ChannelTransport, type TurnDonePayload, type TurnSubmitter } from '../common/index.js';
+export interface TelegramTransportConfig {
+    /** Bot token from @BotFather. Absent → transport stays NOT_CONFIGURED. */
+    readonly botToken?: string;
+    /** Pre-approved chat ids (merged with runtime-paired chats). */
+    readonly allowlistChatIds?: readonly string[];
+}
+export interface TelegramTransportOptions {
+    readonly config: TelegramTransportConfig;
+    readonly dataDir: string;
+    readonly log: ChannelLogger;
+    readonly turnService?: TurnSubmitter;
+    /**
+     * Subscribe to the internal event bus for turn completions.
+     * When absent, inbound turns are still submitted; replies are only sent
+     * once executor B publishes `agent.turn.done` and wires this hook.
+     */
+    readonly subscribeTurnDone?: (handler: (payload: TurnDonePayload) => void) => () => void;
+}
+/** Pairing codes look like `BOOM-123456`. */
+export declare const PAIRING_CODE_PATTERN: RegExp;
+export declare class TelegramTransport implements ChannelTransport {
+    readonly kind: ChannelKind;
+    readonly displayName = "Telegram";
+    private readonly botToken;
+    private readonly log;
+    private readonly turnService;
+    private readonly subscribeTurnDone;
+    private readonly statePath;
+    private allowlist;
+    private pairing;
+    private offset;
+    private running;
+    private loopPromise;
+    private loopAbort;
+    private status;
+    private statusDetail;
+    private unsubscribeTurnDone;
+    /** turnId → chatId, for routing `agent.turn.done` replies. */
+    private readonly pendingReplies;
+    constructor(options: TelegramTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): {
+        status: ChannelRuntimeStatus;
+        detail?: string;
+    };
+    send(target: string, text: string): Promise<void>;
+    /**
+     * Create a one-time pairing code (`BOOM-######`, 10-minute TTL).
+     * The operator sends this code to the bot from the chat to pair.
+     */
+    createPairingCode(): string;
+    /** Remove a chat from the allowlist. Returns true when it was present. */
+    unpairChat(target: string): boolean;
+    /** Current allowlisted chat ids (config ∪ runtime-paired). */
+    getAllowlist(): readonly string[];
+    private pollLoop;
+    private sleep;
+    private getUpdates;
+    private handleUpdate;
+    private handleTurnDone;
+    private consumePairingCode;
+    private prunePairing;
+    private prunePendingReplies;
+    /** Best-effort send: logs instead of throwing (inbound path). */
+    private quietSend;
+    private api;
+    private loadState;
+    private saveState;
+}
+/** Re-export for handler wiring (avoids a magic string in two places). */
+export { TURN_DONE_EVENT };
+export type { TurnDonePayload };

package/dist/node_modules/@boombot/channels/transports/telegram/transport.js

@@ -0,0 +1,395 @@
+/**
+ * Telegram transport for the gateway runtime (phase 2).
+ *
+ * - Outbound: REAL `POST /bot<token>/sendMessage` via global fetch
+ *   (chunked at 4096 chars, code-point aware).
+ * - Inbound: long-polling `getUpdates` with a persisted offset
+ *   (`<dataDir>/channels/telegram/state.json`), exponential backoff on
+ *   errors, clean shutdown via `stop()`.
+ * - Security: fail-closed allowlist. A chat is served only when its id is
+ *   in the allowlist (config `allowlistChatIds` ∪ chats paired at runtime).
+ *   Messages from other chats are dropped with a warn log — never submitted
+ *   to the agent. The bot token is never logged.
+ * - Pairing: `createPairingCode()` returns `BOOM-######` (10-minute TTL);
+ *   when the bot receives the code as a message, the sender's chat is added
+ *   to the allowlist. `unpairChat()` removes it again.
+ * - Turn replies: on `submit()` the transport records turnId → chatId in
+ *   `pendingReplies`. When the internal event bus publishes
+ *   `agent.turn.done` (see `TURN_DONE_EVENT` in common.ts — proposed for
+ *   executor B), the final text is sent back to the chat.
+ *
+ * Boundary: gateway must never import extensions/* — this transport
+ * implements the Bot API directly instead of reusing the extension adapter.
+ */
+import { randomInt } from 'node:crypto';
+import { join } from 'node:path';
+import { readJsonFile, TURN_DONE_EVENT, writeJsonFile, } from '../common/index.js';
+const TELEGRAM_API_BASE = 'https://api.telegram.org';
+const MAX_TEXT_LENGTH = 4096;
+/** Long-poll window (seconds) requested from getUpdates. */
+const POLL_TIMEOUT_SECONDS = 30;
+/** Pairing codes live for 10 minutes. */
+const PAIRING_TTL_MS = 10 * 60 * 1000;
+/** Cap on stored pending pairing codes. */
+const MAX_PAIRING_CODES = 20;
+function isApiResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.ok === 'boolean');
+}
+/** Pairing codes look like `BOOM-123456`. */
+export const PAIRING_CODE_PATTERN = /^BOOM-\d{6}$/;
+function newPairingCode() {
+    return `BOOM-${String(randomInt(0, 1_000_000)).padStart(6, '0')}`;
+}
+function chunkText(text) {
+    const codePoints = Array.from(text);
+    const chunks = [];
+    for (let i = 0; i < codePoints.length; i += MAX_TEXT_LENGTH) {
+        chunks.push(codePoints.slice(i, i + MAX_TEXT_LENGTH).join(''));
+    }
+    return chunks;
+}
+export class TelegramTransport {
+    kind = 'telegram';
+    displayName = 'Telegram';
+    botToken;
+    log;
+    turnService;
+    subscribeTurnDone;
+    statePath;
+    allowlist = new Set();
+    pairing = [];
+    offset;
+    running = false;
+    loopPromise = null;
+    loopAbort = null;
+    status = 'disconnected';
+    statusDetail = 'NOT_CONFIGURED';
+    unsubscribeTurnDone;
+    /** turnId → chatId, for routing `agent.turn.done` replies. */
+    pendingReplies = new Map();
+    constructor(options) {
+        const token = options.config.botToken?.trim();
+        this.botToken = token === '' ? undefined : token;
+        this.log = options.log;
+        this.turnService = options.turnService;
+        this.subscribeTurnDone = options.subscribeTurnDone;
+        this.statePath = join(options.dataDir, 'channels', 'telegram', 'state.json');
+        for (const chatId of options.config.allowlistChatIds ?? []) {
+            this.allowlist.add(chatId);
+        }
+    }
+    // -- lifecycle -----------------------------------------------------------
+    async start() {
+        if (this.botToken === undefined) {
+            this.status = 'disconnected';
+            this.statusDetail = 'NOT_CONFIGURED';
+            this.log.info('telegram: botToken not configured — transport not running');
+            return;
+        }
+        this.loadState();
+        try {
+            const me = await this.api('getMe', {});
+            if (!me.ok) {
+                throw new Error(me.description ?? 'getMe failed');
+            }
+        }
+        catch (err) {
+            this.status = 'error';
+            this.statusDetail = err instanceof Error ? err.message : 'GETME_FAILED';
+            this.log.error('telegram: botToken check failed', {
+                detail: this.statusDetail,
+            });
+            return;
+        }
+        if (this.subscribeTurnDone !== undefined) {
+            this.unsubscribeTurnDone = this.subscribeTurnDone((payload) => {
+                this.handleTurnDone(payload);
+            });
+        }
+        this.status = 'connected';
+        this.statusDetail = undefined;
+        this.running = true;
+        this.loopAbort = new AbortController();
+        this.loopPromise = this.pollLoop();
+        this.log.info('telegram: long-polling started');
+    }
+    async stop() {
+        this.running = false;
+        this.loopAbort?.abort();
+        if (this.loopPromise !== null) {
+            await this.loopPromise;
+            this.loopPromise = null;
+        }
+        this.unsubscribeTurnDone?.();
+        this.unsubscribeTurnDone = undefined;
+        this.saveState();
+        if (this.status === 'connected') {
+            this.status = 'disconnected';
+            this.statusDetail = 'STOPPED';
+        }
+        this.log.info('telegram: stopped');
+    }
+    getStatus() {
+        this.prunePairing();
+        if (this.status === 'connected' && this.pairing.length > 0) {
+            return { status: 'pending', detail: 'PAIRING' };
+        }
+        return this.statusDetail === undefined
+            ? { status: this.status }
+            : { status: this.status, detail: this.statusDetail };
+    }
+    // -- outbound ------------------------------------------------------------
+    async send(target, text) {
+        if (this.botToken === undefined) {
+            throw new Error('NOT_CONFIGURED: telegram has no botToken');
+        }
+        if (target.trim() === '' || text.trim() === '') {
+            throw new Error('INVALID_ARGUMENT: target/text must not be empty');
+        }
+        for (const chunk of chunkText(text)) {
+            const res = await this.api('sendMessage', {
+                chat_id: target.trim(),
+                text: chunk,
+            });
+            if (!res.ok) {
+                throw new Error(`SEND_FAILED: ${res.description ?? 'unknown error'}`);
+            }
+        }
+    }
+    // -- pairing -------------------------------------------------------------
+    /**
+     * Create a one-time pairing code (`BOOM-######`, 10-minute TTL).
+     * The operator sends this code to the bot from the chat to pair.
+     */
+    createPairingCode() {
+        this.prunePairing();
+        const code = newPairingCode();
+        this.pairing.push({ code, createdAt: Date.now() });
+        if (this.pairing.length > MAX_PAIRING_CODES) {
+            this.pairing.splice(0, this.pairing.length - MAX_PAIRING_CODES);
+        }
+        this.saveState();
+        return code;
+    }
+    /** Remove a chat from the allowlist. Returns true when it was present. */
+    unpairChat(target) {
+        const removed = this.allowlist.delete(target);
+        if (removed) {
+            this.saveState();
+            this.log.info('telegram: unpaired chat', { chatId: target });
+        }
+        return removed;
+    }
+    /** Current allowlisted chat ids (config ∪ runtime-paired). */
+    getAllowlist() {
+        return [...this.allowlist];
+    }
+    // -- inbound polling -----------------------------------------------------
+    async pollLoop() {
+        let consecutiveErrors = 0;
+        while (this.running) {
+            try {
+                const updates = await this.getUpdates();
+                consecutiveErrors = 0;
+                for (const update of updates) {
+                    await this.handleUpdate(update);
+                }
+            }
+            catch (err) {
+                if (!this.running)
+                    break;
+                consecutiveErrors += 1;
+                const delayMs = Math.min(1000 * 2 ** (consecutiveErrors - 1), 30_000);
+                this.status = 'error';
+                this.statusDetail =
+                    err instanceof Error ? err.message : 'POLL_FAILED';
+                this.log.warn('telegram: poll error, retrying later', {
+                    delayMs,
+                    attempt: consecutiveErrors,
+                });
+                await this.sleep(delayMs);
+            }
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, ms);
+            // Wake early on stop.
+            this.loopAbort?.signal.addEventListener('abort', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    async getUpdates() {
+        const params = new URLSearchParams({
+            timeout: String(POLL_TIMEOUT_SECONDS),
+            allowed_updates: JSON.stringify(['message']),
+        });
+        if (this.offset !== undefined) {
+            params.set('offset', String(this.offset));
+        }
+        const res = await this.api('getUpdates', {}, params, 40_000);
+        if (!res.ok) {
+            throw new Error(`GETUPDATES_FAILED: ${res.description ?? 'unknown'}`);
+        }
+        const list = Array.isArray(res.result) ? res.result : [];
+        for (const update of list) {
+            this.offset = update.update_id + 1;
+        }
+        if (list.length > 0) {
+            this.saveState();
+        }
+        return list;
+    }
+    async handleUpdate(update) {
+        const message = update.message ?? update.edited_message;
+        const text = message?.text?.trim();
+        if (message === undefined || text === undefined || text === '') {
+            return;
+        }
+        const chatId = String(message.chat.id);
+        // Pairing code from the chat owner.
+        if (PAIRING_CODE_PATTERN.test(text.toUpperCase())) {
+            const ok = this.consumePairingCode(text.toUpperCase(), chatId);
+            await this.quietSend(chatId, ok
+                ? 'This chat is now paired with BoomBot. You can chat with the agent here from now on.'
+                : 'Pairing code is invalid or expired. Create a new code with the channel.pair command.');
+            return;
+        }
+        // Fail-closed allowlist: unknown chats are dropped, never submitted.
+        if (!this.allowlist.has(chatId)) {
+            this.log.warn('telegram: ignoring message from non-allowlisted chat', {
+                chatId,
+            });
+            return;
+        }
+        if (this.turnService === undefined) {
+            await this.quietSend(chatId, 'Gateway is not ready to handle requests (turnService is not configured).');
+            return;
+        }
+        try {
+            const { turnId } = await this.turnService.submit({
+                input: message.text ?? text,
+                channel: 'telegram',
+                replyTo: chatId,
+            });
+            this.pendingReplies.set(turnId, { chatId, createdAt: Date.now() });
+            this.prunePendingReplies();
+        }
+        catch (err) {
+            this.log.error('telegram: turn submit failed', {
+                chatId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            await this.quietSend(chatId, 'Could not send the request to the agent. Please try again later.');
+        }
+    }
+    handleTurnDone = (payload) => {
+        const pending = this.pendingReplies.get(payload.turnId);
+        const chatId = pending?.chatId ??
+            (payload.channel === 'telegram' ? payload.replyTo : undefined);
+        if (chatId === undefined) {
+            return;
+        }
+        this.pendingReplies.delete(payload.turnId);
+        const text = payload.status === 'completed'
+            ? payload.output?.trim() !== '' && payload.output !== undefined
+                ? payload.output
+                : '(turn completed, no content)'
+            : `Turn failed${payload.error !== undefined && payload.error !== '' ? `: ${payload.error}` : ''}.`;
+        void this.quietSend(chatId, text);
+    };
+    consumePairingCode(code, chatId) {
+        this.prunePairing();
+        const index = this.pairing.findIndex((entry) => entry.code === code);
+        if (index === -1) {
+            return false;
+        }
+        this.pairing.splice(index, 1);
+        this.allowlist.add(chatId);
+        this.saveState();
+        this.log.info('telegram: paired new chat', { chatId });
+        return true;
+    }
+    prunePairing() {
+        const now = Date.now();
+        this.pairing = this.pairing.filter((entry) => now - entry.createdAt < PAIRING_TTL_MS);
+    }
+    prunePendingReplies() {
+        const now = Date.now();
+        for (const [turnId, entry] of this.pendingReplies) {
+            if (now - entry.createdAt > 60 * 60 * 1000) {
+                this.pendingReplies.delete(turnId);
+            }
+        }
+    }
+    /** Best-effort send: logs instead of throwing (inbound path). */
+    async quietSend(chatId, text) {
+        try {
+            await this.send(chatId, text);
+        }
+        catch (err) {
+            this.log.error('telegram: send message failed', {
+                chatId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // -- Bot API ---------------------------------------------------------------
+    async api(method, body, params, timeoutMs = 15_000) {
+        if (this.botToken === undefined) {
+            throw new Error('NOT_CONFIGURED');
+        }
+        // NOTE: the token travels in the URL path (Bot API convention).
+        // Never log the URL, and never include it in thrown errors.
+        const url = `${TELEGRAM_API_BASE}/bot${this.botToken}/${method}` +
+            (params !== undefined ? `?${params.toString()}` : '');
+        const isGet = method === 'getUpdates' || method === 'getMe';
+        const response = await fetch(url, {
+            method: isGet ? 'GET' : 'POST',
+            headers: isGet ? undefined : { 'content-type': 'application/json' },
+            body: isGet ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const data = await response.json();
+        if (!isApiResponse(data)) {
+            throw new Error(`Telegram API returned an unrecognized body (${method}).`);
+        }
+        return data;
+    }
+    // -- persistence -----------------------------------------------------------
+    loadState() {
+        const state = readJsonFile(this.statePath);
+        if (state === undefined) {
+            return;
+        }
+        if (typeof state.offset === 'number') {
+            this.offset = state.offset;
+        }
+        for (const chatId of state.allowlist) {
+            this.allowlist.add(chatId);
+        }
+        this.pairing = Array.isArray(state.pairing) ? state.pairing : [];
+        this.prunePairing();
+    }
+    saveState() {
+        const state = {
+            offset: this.offset,
+            allowlist: [...this.allowlist],
+            pairing: this.pairing,
+        };
+        try {
+            writeJsonFile(this.statePath, state);
+        }
+        catch (err) {
+            this.log.error('telegram: save state failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+/** Re-export for handler wiring (avoids a magic string in two places). */
+export { TURN_DONE_EVENT };

package/dist/node_modules/@boombot/channels/transports/telegram.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular telegram package */
+export * from './telegram/index.js';

package/dist/node_modules/@boombot/channels/transports/telegram.js

@@ -0,0 +1,2 @@
+/** Re-export from modular telegram package */
+export * from './telegram/index.js';

package/dist/node_modules/@boombot/channels/transports/tiktok/index.d.ts

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/tiktok/index.js

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/tiktok/transport.d.ts

@@ -0,0 +1,27 @@
+import type { ChannelKind } from '@boombot/protocol';
+import type { ChannelLogger, ChannelRuntimeStatus, ChannelTransport } from '../common/index.js';
+export interface TikTokTransportConfig {
+    readonly enabled?: boolean;
+    readonly appId?: string;
+    readonly clientSecret?: string;
+    readonly accessToken?: string;
+}
+export declare class TikTokTransport implements ChannelTransport {
+    readonly kind: ChannelKind;
+    readonly displayName = "TikTok";
+    private readonly enabled;
+    private readonly appId;
+    private readonly clientSecret;
+    private readonly accessToken;
+    private readonly log;
+    private status;
+    private statusDetail;
+    constructor(config: TikTokTransportConfig, log: ChannelLogger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(target: string, text: string): Promise<void>;
+    getStatus(): {
+        status: ChannelRuntimeStatus;
+        detail?: string;
+    };
+}

package/dist/node_modules/@boombot/channels/transports/tiktok/transport.js

@@ -0,0 +1,97 @@
+const TIKTOK_API_BASE = 'https://business-api.tiktok.com/open_api/v1.3';
+export class TikTokTransport {
+    kind = 'tiktok';
+    displayName = 'TikTok';
+    enabled;
+    appId;
+    clientSecret;
+    accessToken;
+    log;
+    status = 'disconnected';
+    statusDetail = 'NOT_CONFIGURED';
+    constructor(config, log) {
+        this.enabled = config.enabled !== false;
+        this.appId = config.appId?.trim() || undefined;
+        this.clientSecret = config.clientSecret?.trim() || undefined;
+        this.accessToken = config.accessToken?.trim() || undefined;
+        this.log = log;
+    }
+    async start() {
+        if (!this.enabled) {
+            this.statusDetail = 'DISABLED';
+            return;
+        }
+        if (this.appId === undefined ||
+            this.clientSecret === undefined ||
+            this.accessToken === undefined) {
+            this.statusDetail = 'NOT_CONFIGURED';
+            this.log.info('tiktok: missing appId/clientSecret/accessToken');
+            return;
+        }
+        try {
+            const query = new URLSearchParams({
+                app_id: this.appId,
+                secret: this.clientSecret,
+            });
+            const response = await fetch(`${TIKTOK_API_BASE}/oauth2/advertiser/get/?${query}`, {
+                headers: { 'Access-Token': this.accessToken },
+                signal: AbortSignal.timeout(15_000),
+            });
+            const data = (await response.json());
+            if (!response.ok || data.code !== 0) {
+                throw new Error(data.code === undefined ? `HTTP ${response.status}` : `API ${data.code}`);
+            }
+            this.status = 'connected';
+            this.statusDetail = undefined;
+            this.log.info('tiktok: connected (outbound only)');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.statusDetail =
+                error instanceof Error ? error.message : 'CONNECT_FAILED';
+            this.log.error('tiktok: credential check failed', {
+                detail: this.statusDetail,
+            });
+        }
+    }
+    async stop() {
+        if (this.status === 'connected') {
+            this.status = 'disconnected';
+            this.statusDetail = 'STOPPED';
+        }
+        this.log.info('tiktok: stopped');
+    }
+    async send(target, text) {
+        if (!this.enabled)
+            throw new Error('DISABLED: tiktok is disabled');
+        if (this.accessToken === undefined) {
+            throw new Error('NOT_CONFIGURED: tiktok missing accessToken');
+        }
+        const conversationId = target.trim();
+        if (conversationId === '' || text.trim() === '') {
+            throw new Error('INVALID_ARGUMENT: target/text must not be empty');
+        }
+        const response = await fetch(`${TIKTOK_API_BASE}/business/message/send/`, {
+            method: 'POST',
+            headers: {
+                'Access-Token': this.accessToken,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                conversation_id: conversationId,
+                message_type: 'TEXT',
+                content: { text },
+            }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        const data = (await response.json().catch(() => undefined));
+        if (!response.ok || data?.code !== 0) {
+            throw new Error(`SEND_FAILED: ${data?.code === undefined ? `HTTP ${response.status}` : `API ${data.code}`}`);
+        }
+    }
+    getStatus() {
+        return this.statusDetail === undefined
+            ? { status: this.status }
+            : { status: this.status, detail: this.statusDetail };
+    }
+}

package/dist/node_modules/@boombot/channels/transports/tiktok.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular tiktok package */
+export * from './tiktok/index.js';

package/dist/node_modules/@boombot/channels/transports/tiktok.js

@@ -0,0 +1,2 @@
+/** Re-export from modular tiktok package */
+export * from './tiktok/index.js';

package/dist/node_modules/@boombot/channels/transports/whatsapp/index.d.ts

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/whatsapp/index.js

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/whatsapp/transport.d.ts

@@ -0,0 +1,38 @@
+import type { ChannelKind } from '@boombot/protocol';
+import { type ChannelLogger, type ChannelRuntimeStatus, type ChannelTransport, type ChannelWebhookRequest, type ChannelWebhookResponse, type InboundTransportOptions } from '../common/index.js';
+export interface WhatsAppTransportConfig {
+    readonly enabled?: boolean;
+    readonly phoneNumberId?: string;
+    readonly accessToken?: string;
+    readonly verifyToken?: string;
+    readonly appSecret?: string;
+    readonly allowlistChatIds?: readonly string[];
+}
+export declare class WhatsAppTransport implements ChannelTransport {
+    readonly kind: ChannelKind;
+    readonly displayName = "WhatsApp";
+    private readonly enabled;
+    private readonly phoneNumberId;
+    private readonly accessToken;
+    private readonly verifyToken;
+    private readonly appSecret;
+    private readonly allowlist;
+    private readonly log;
+    private readonly turnService;
+    private readonly subscribeTurnDone;
+    private readonly pendingReplies;
+    private readonly deduplicator;
+    private unsubscribeTurnDone;
+    private status;
+    private statusDetail;
+    constructor(config: WhatsAppTransportConfig, log: ChannelLogger, inbound?: InboundTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): {
+        status: ChannelRuntimeStatus;
+        detail?: string;
+    };
+    handleWebhook(request: ChannelWebhookRequest): Promise<ChannelWebhookResponse>;
+    send(target: string, text: string): Promise<void>;
+    private onTurnDone;
+}