beecork 1.7.0 → 2.0.0

package/dist/channels/discord.js

@@ -1,266 +0,0 @@
-/*
- * Discord integration via discord.js (peer-optional, dynamic-imported).
- *
- * discord.js's strict union types (PartialGroupDMChannel, TextChannel, etc.)
- * require narrowing at every send/sendTyping callsite. The runtime channel
- * objects we receive in handlers all support these methods, but expressing
- * that to TypeScript via the published types is a significant refactor with
- * no runtime benefit. We accept `any` at this library boundary — same pattern
- * as the WhatsApp/baileys integration.
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { logger } from '../util/logger.js';
-import { parseTabMessage } from '../util/text.js';
-import { sendChunkedResponse } from './send-helpers.js';
-import { inboundLimiter } from '../util/rate-limiter.js';
-import { saveMedia, isOversized } from '../media/store.js';
-import { VoiceState } from './voice-state.js';
-import { processInboundMessage } from './pipeline.js';
-import { isChannelAdmin } from './admin.js';
-export class DiscordChannel {
-    id = 'discord';
-    name = 'Discord';
-    maxMessageLength = 2000;
-    client = null; // Discord.js Client
-    ctx;
-    allowedUserIds;
-    voice = new VoiceState('discord');
-    constructor(ctx) {
-        this.ctx = ctx;
-        this.allowedUserIds = new Set((ctx.config.discord?.allowedUserIds ?? []).map(String));
-    }
-    async start() {
-        const discordConfig = this.ctx.config.discord;
-        if (!discordConfig?.token) {
-            logger.warn('No Discord token configured');
-            return;
-        }
-        // Dynamic import since discord.js might not be installed
-        const { Client, GatewayIntentBits, Events } = await import('discord.js');
-        this.client = new Client({
-            intents: [
-                GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages,
-                GatewayIntentBits.DirectMessages,
-                GatewayIntentBits.MessageContent,
-            ],
-        });
-        // Voice providers (STT + TTS)
-        this.voice.init(this.ctx.config);
-        this.client.on(Events.MessageCreate, async (message) => {
-            // Ignore bot messages
-            if (message.author.bot)
-                return;
-            const isDM = !message.guild;
-            const isMentioned = message.mentions.has(this.client.user);
-            // In DMs: only allow users in the allowlist
-            // In servers: only respond if @mentioned
-            if (isDM) {
-                if (!this.allowedUserIds.has(message.author.id))
-                    return;
-            }
-            else {
-                if (!isMentioned)
-                    return;
-            }
-            // Rate limit
-            if (!inboundLimiter.check(this.id)) {
-                await message
-                    .reply("I'm receiving too many messages right now. Please wait a moment.")
-                    .catch(() => { });
-                return;
-            }
-            const text = message.content
-                .replace(/<@!?\d+>/g, '') // Remove mentions
-                .trim();
-            // Warm up STT connection on first message with attachments.
-            // (Discord intentionally only warms up; it doesn't transcribe like Telegram/WhatsApp.)
-            if (message.attachments.size > 0)
-                await this.voice.warmup();
-            // Download attachments
-            const media = [];
-            for (const attachment of message.attachments.values()) {
-                try {
-                    if (isOversized(attachment.size)) {
-                        logger.warn(`Skipping oversized Discord attachment: ${attachment.size} bytes`);
-                        continue;
-                    }
-                    const response = await fetch(attachment.url, { signal: AbortSignal.timeout(30000) });
-                    if (!response.ok)
-                        continue;
-                    const buffer = Buffer.from(await response.arrayBuffer());
-                    const ext = attachment.name?.split('.').pop() || 'bin';
-                    const filePath = saveMedia(buffer, ext, attachment.name);
-                    let type = 'document';
-                    if (attachment.contentType?.startsWith('image/'))
-                        type = 'image';
-                    else if (attachment.contentType?.startsWith('video/'))
-                        type = 'video';
-                    else if (attachment.contentType?.startsWith('audio/'))
-                        type = 'audio';
-                    media.push({
-                        type,
-                        mimeType: attachment.contentType || 'application/octet-stream',
-                        filePath,
-                        fileName: attachment.name,
-                    });
-                }
-                catch (err) {
-                    logger.warn('Failed to download Discord attachment:', err);
-                }
-            }
-            if (!text && media.length === 0)
-                return;
-            try {
-                // Show typing
-                await message.channel.sendTyping().catch(() => { });
-                // Parse tab name (needed for command handling check)
-                const { tabName } = parseTabMessage(text || '');
-                // Shared command handler
-                if (text.startsWith('/')) {
-                    const { handleSharedCommand } = await import('./command-handler.js');
-                    const cmdResult = await handleSharedCommand({
-                        userId: message.author.id,
-                        text,
-                        isAdmin: isChannelAdmin(this.allowedUserIds, message.author.id, this.ctx.config.discord?.adminUserId),
-                        channelId: 'discord',
-                    }, this.ctx.tabManager);
-                    if (cmdResult.handled) {
-                        if (cmdResult.response)
-                            await message.reply(cmdResult.response);
-                        return;
-                    }
-                }
-                // Discord-specific: use thread name as tab if in a thread
-                let overrideTabName;
-                if (message.channel.isThread?.()) {
-                    const sanitized = (message.channel.name || '')
-                        .replace(/[^a-zA-Z0-9-]/g, '-')
-                        .replace(/^-+|-+$/g, '')
-                        .slice(0, 32);
-                    // Run the synthesized name through validateTabName so weird thread
-                    // names (empty, starts with hyphen, "default") don't blow up downstream.
-                    const { validateTabName } = await import('../config.js');
-                    if (sanitized && tabName === 'default' && !validateTabName(sanitized)) {
-                        overrideTabName = sanitized;
-                    }
-                }
-                // Typing indicator refresh
-                const typingInterval = setInterval(() => {
-                    message.channel.sendTyping().catch(() => { });
-                }, 8000); // Discord typing lasts 10s
-                try {
-                    // Shared message pipeline
-                    const pipelineResult = await processInboundMessage({
-                        text: text || '',
-                        media,
-                        channelId: 'discord',
-                        tabManager: this.ctx.tabManager,
-                        voiceReplyMode: this.ctx.config.voice?.replyMode,
-                        ttsProvider: this.voice.tts,
-                        userId: message.author.id,
-                        sendProgress: (msg) => {
-                            message.channel.send(msg).catch(() => { });
-                        },
-                        overrideTabName,
-                    });
-                    clearInterval(typingInterval);
-                    // Empty result means no prompt and no media
-                    if (!pipelineResult.responseText)
-                        return;
-                    // Voice reply if TTS generated audio
-                    if (pipelineResult.audioPath) {
-                        await message.reply({ files: [pipelineResult.audioPath] });
-                        if (pipelineResult.voiceOnly)
-                            return;
-                    }
-                    // Send text response
-                    await this.sendResponse(message, pipelineResult.responseText, pipelineResult.tabName);
-                }
-                catch (err) {
-                    clearInterval(typingInterval);
-                    throw err;
-                }
-            }
-            catch (err) {
-                logger.error('Discord message handler error:', err);
-                await message.reply('Something went wrong processing your message.').catch(() => { });
-            }
-        });
-        this.client.on(Events.ClientReady, () => {
-            logger.info(`Discord bot ready as ${this.client.user?.tag}`);
-        });
-        await this.client.login(discordConfig.token);
-    }
-    stop() {
-        if (this.client) {
-            this.client.destroy();
-            this.client = null;
-        }
-        logger.info('Discord bot stopped');
-    }
-    async sendMessage(peerId, text, _options) {
-        if (!this.client)
-            return;
-        try {
-            const channel = await this.client.channels.fetch(peerId);
-            if (!channel?.isTextBased())
-                return;
-            await sendChunkedResponse({
-                text,
-                maxLength: this.maxMessageLength,
-                retryLabel: 'discord-send',
-                sendChunk: (chunk) => channel.send(chunk),
-            });
-        }
-        catch (err) {
-            logger.error(`Discord send failed for ${peerId}:`, err);
-        }
-    }
-    async sendNotification(message, _urgent) {
-        if (!this.client)
-            return;
-        // Send to all allowed users via DM
-        for (const userId of this.allowedUserIds) {
-            try {
-                const user = await this.client.users.fetch(userId);
-                if (user) {
-                    await user.send(message);
-                }
-            }
-            catch (err) {
-                logger.error(`Discord notification failed for ${userId}:`, err);
-            }
-        }
-    }
-    async setTyping(peerId, active) {
-        if (!this.client || !active)
-            return;
-        try {
-            const channel = await this.client.channels.fetch(peerId);
-            if (channel?.isTextBased()) {
-                await channel.sendTyping();
-            }
-        }
-        catch { }
-    }
-    async sendResponse(message, text, tabName) {
-        // Discord quirk: first chunk uses message.reply so it threads under the
-        // original user message; follow-ups use channel.send. sendChunkedResponse
-        // handles prefix + chunking + retry envelope; the closure-tracked chunkIdx
-        // keeps the "first chunk replies, rest send" behavior.
-        let chunkIdx = 0;
-        await sendChunkedResponse({
-            text,
-            tabName,
-            maxLength: this.maxMessageLength,
-            retryDelays: [1000, 5000],
-            retryLabel: 'discord-send',
-            sendChunk: (chunk) => {
-                const isFirst = chunkIdx === 0;
-                chunkIdx++;
-                return isFirst ? message.reply(chunk) : message.channel.send(chunk);
-            },
-        });
-    }
-}

package/dist/channels/index.d.ts

@@ -1,7 +0,0 @@
-export { ChannelRegistry } from './registry.js';
-export { TelegramChannel } from './telegram.js';
-export { WhatsAppChannel } from './whatsapp.js';
-export { WebhookChannel } from './webhook.js';
-export { DiscordChannel } from './discord.js';
-export { loadCommunityChannels } from './loader.js';
-export type { Channel, ChannelContext, MediaAttachment, SendOptions } from './types.js';

package/dist/channels/index.js

@@ -1,6 +0,0 @@
-export { ChannelRegistry } from './registry.js';
-export { TelegramChannel } from './telegram.js';
-export { WhatsAppChannel } from './whatsapp.js';
-export { WebhookChannel } from './webhook.js';
-export { DiscordChannel } from './discord.js';
-export { loadCommunityChannels } from './loader.js';

package/dist/channels/loader.d.ts

@@ -1,7 +0,0 @@
-import type { Channel, ChannelContext } from './types.js';
-/**
- * Discover and load community channel packages from node_modules.
- * Convention: packages named `beecork-channel-<name>` must export a default
- * class implementing the Channel interface.
- */
-export declare function loadCommunityChannels(ctx: ChannelContext): Promise<Channel[]>;

package/dist/channels/loader.js

@@ -1,87 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../util/logger.js';
-const CHANNEL_PREFIX = 'beecork-channel-';
-/**
- * Discover and load community channel packages from node_modules.
- * Convention: packages named `beecork-channel-<name>` must export a default
- * class implementing the Channel interface.
- */
-export async function loadCommunityChannels(ctx) {
-    const channels = [];
-    // Require explicit opt-in via config to prevent supply-chain attacks
-    const allowlist = ctx.config.communityChannels;
-    if (!allowlist || allowlist.length === 0)
-        return channels;
-    // Look in global and local node_modules
-    const searchPaths = [
-        path.join(process.cwd(), 'node_modules'),
-        // Global npm modules path varies by OS — try common locations
-    ];
-    // Also check if beecork is installed globally
-    try {
-        const globalPath = path.dirname(require.resolve('beecork/package.json'));
-        const globalNodeModules = path.join(globalPath, '..');
-        if (fs.existsSync(globalNodeModules)) {
-            searchPaths.push(globalNodeModules);
-        }
-    }
-    catch { }
-    for (const searchPath of searchPaths) {
-        if (!fs.existsSync(searchPath))
-            continue;
-        try {
-            const dirs = fs.readdirSync(searchPath);
-            for (const dir of dirs) {
-                if (!dir.startsWith(CHANNEL_PREFIX))
-                    continue;
-                if (!allowlist.includes(dir))
-                    continue;
-                const pkgPath = path.join(searchPath, dir);
-                try {
-                    // Read package.json to find the main entry
-                    const pkgJson = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json'), 'utf-8'));
-                    const main = pkgJson.main || 'index.js';
-                    const entryPath = path.join(pkgPath, main);
-                    if (!fs.existsSync(entryPath)) {
-                        logger.warn(`Community channel ${dir}: entry point not found at ${entryPath}`);
-                        continue;
-                    }
-                    // Dynamic import — community channels run with full daemon access:
-                    // they can read every config token (Telegram, Discord, WhatsApp,
-                    // notification provider keys) AND every environment variable the
-                    // daemon inherits (including SSH-agent sockets, GitHub tokens,
-                    // anything sourced from your shell profile). A compromised
-                    // community-channel package is effectively a root credential drop.
-                    // Pin versions in package.json, audit before opting in, and treat
-                    // every entry in `communityChannels` as a trust anchor.
-                    logger.warn(`Loading community channel "${dir}" — this package will have FULL access to your channel tokens (Telegram/Discord/WhatsApp) and every environment variable inherited by the daemon (including SSH keys). Only enable if you trust the package author and have audited the version.`);
-                    const module = await import(entryPath);
-                    const ChannelClass = module.default || module[Object.keys(module)[0]];
-                    if (!ChannelClass || typeof ChannelClass !== 'function') {
-                        logger.warn(`Community channel ${dir}: no default export found`);
-                        continue;
-                    }
-                    const instance = new ChannelClass(ctx);
-                    // Validate it implements Channel interface (duck typing)
-                    if (!instance.id ||
-                        !instance.name ||
-                        typeof instance.start !== 'function' ||
-                        typeof instance.stop !== 'function') {
-                        logger.warn(`Community channel ${dir}: does not implement Channel interface`);
-                        continue;
-                    }
-                    channels.push(instance);
-                    logger.info(`Community channel loaded: ${instance.name} (${instance.id}) from ${dir}`);
-                }
-                catch (err) {
-                    logger.warn(`Failed to load community channel ${dir}:`, err);
-                }
-            }
-        }
-        catch (err) {
-            logger.warn(`Failed to scan ${searchPath}:`, err);
-        }
-    }
-    return channels;
-}

package/dist/channels/pipeline.d.ts

@@ -1,50 +0,0 @@
-import type { MediaAttachment } from './types.js';
-import type { TabManager } from '../session/manager.js';
-import type { TTSProvider } from '../voice/tts.js';
-export interface PipelineOptions {
-    /** Raw message text (may include /tab prefix) */
-    text: string;
-    /** Downloaded media attachments */
-    media: MediaAttachment[];
-    /** Channel identifier for logging */
-    channelId: string;
-    /** Tab manager instance */
-    tabManager: TabManager;
-    /** Voice reply mode from config */
-    voiceReplyMode?: 'voice' | 'both' | 'text';
-    /** TTS provider (if configured) */
-    ttsProvider?: TTSProvider | null;
-    /** User ID for project routing */
-    userId: string;
-    /** Callback to send progress messages to the user */
-    sendProgress: (message: string) => void;
-    /**
-     * Override the tab name (e.g., group tabs in Telegram, thread tabs in Discord).
-     * When set, parseTabMessage result is ignored for the tab name.
-     */
-    overrideTabName?: string;
-    /**
-     * Callback invoked on each text chunk from Claude (for streaming).
-     * Only Telegram uses this currently.
-     */
-    onTextChunk?: (chunk: string) => void;
-}
-export interface PipelineResult {
-    /** The final response text (already includes "Error: " prefix on errors) */
-    responseText: string;
-    /** The tab name that was actually used */
-    tabName: string;
-    /** Whether the response was an error */
-    isError: boolean;
-    /** Path to TTS audio file, if voice reply was generated */
-    audioPath?: string;
-    /** Whether voice-only mode is active (caller should skip text response) */
-    voiceOnly?: boolean;
-}
-/**
- * Process an inbound message through the shared pipeline.
- *
- * Returns the response text and optional audio path. The caller (channel)
- * is responsible for delivering the response using its platform API.
- */
-export declare function processInboundMessage(opts: PipelineOptions): Promise<PipelineResult>;

package/dist/channels/pipeline.js

@@ -1,92 +0,0 @@
-/**
- * Shared message-processing pipeline for all channels.
- *
- * Handles the common flow: project routing -> media prompt building ->
- * tab message sending -> progress tracking -> TTS voice reply.
- *
- * Each channel remains responsible for:
- *   - Platform-specific message parsing and media download
- *   - Typing indicators (passed as a callback)
- *   - Sending the final response via its own API
- *   - Any channel-specific features (Telegram streaming, Discord threads, etc.)
- */
-import { parseTabMessage, buildMediaPrompt } from '../util/text.js';
-import { ProgressTracker } from '../util/progress.js';
-import { logger } from '../util/logger.js';
-/**
- * Process an inbound message through the shared pipeline.
- *
- * Returns the response text and optional audio path. The caller (channel)
- * is responsible for delivering the response using its platform API.
- */
-export async function processInboundMessage(opts) {
-    const { text, media, channelId, tabManager, voiceReplyMode, ttsProvider, userId, sendProgress, overrideTabName, onTextChunk, } = opts;
-    // 1. Parse tab name and prompt from the message text
-    const parsed = parseTabMessage(text);
-    const rawPrompt = parsed.prompt;
-    let tabName = parsed.tabName;
-    // Allow channel to override tab name (group tabs, thread tabs, etc.).
-    // Validate centrally so each channel doesn't need its own check — keeps the
-    // CLAUDE.md "validation is centralized" rule honest. `default` is allowed.
-    if (overrideTabName) {
-        if (overrideTabName !== 'default') {
-            const { validateTabName } = await import('../config.js');
-            const overrideErr = validateTabName(overrideTabName);
-            if (overrideErr) {
-                return { responseText: `Invalid tab name: ${overrideErr}`, tabName, isError: true };
-            }
-        }
-        tabName = overrideTabName;
-    }
-    if (!rawPrompt && media.length === 0) {
-        return { responseText: '', tabName, isError: false };
-    }
-    // 2. Smart project routing
-    const { resolveProjectRoute } = await import('./command-handler.js');
-    const route = await resolveProjectRoute(rawPrompt, tabName, text, userId);
-    if (route.confirmationMessage) {
-        return {
-            responseText: route.confirmationMessage,
-            tabName,
-            isError: false,
-        };
-    }
-    const effectiveTabName = route.effectiveTabName;
-    const projectPath = route.projectPath;
-    // 3. Build prompt with media references
-    const prompt = buildMediaPrompt(media, rawPrompt);
-    logger.info(`[${channelId}] Pipeline processing for tab "${effectiveTabName}"`);
-    // 4. Create progress tracker
-    const progressTracker = new ProgressTracker(effectiveTabName, sendProgress);
-    // 5. Send message to tab
-    const result = await tabManager.sendMessage(effectiveTabName, prompt, {
-        onTextChunk,
-        onToolUse: (name, input) => progressTracker.record(name, input),
-        projectPath,
-    });
-    progressTracker.stop();
-    // 6. Build response text
-    const isError = result.error;
-    const responseText = isError ? `Error: ${result.text}` : result.text || '(empty response)';
-    // 7. TTS voice reply (shared logic)
-    let audioPath;
-    let voiceOnly = false;
-    if (ttsProvider && (voiceReplyMode === 'voice' || voiceReplyMode === 'both')) {
-        try {
-            audioPath = await ttsProvider.synthesize(responseText);
-            if (voiceReplyMode === 'voice') {
-                voiceOnly = true;
-            }
-        }
-        catch (err) {
-            logger.warn(`[${channelId}] TTS failed, falling back to text:`, err);
-        }
-    }
-    return {
-        responseText,
-        tabName: effectiveTabName,
-        isError,
-        audioPath,
-        voiceOnly,
-    };
-}

package/dist/channels/registry.d.ts

@@ -1,36 +0,0 @@
-import type { Channel } from './types.js';
-import type { MediaAttachment } from '../types.js';
-/**
- * ChannelRegistry manages the lifecycle of all channels.
- * Channels register themselves, and the registry handles start/stop/broadcast.
- */
-export declare class ChannelRegistry {
-    private channels;
-    /** Register a channel */
-    register(channel: Channel): void;
-    /**
-     * Start all registered channels in parallel. Each channel's start() is an
-     * independent network handshake (Telegram getMe, Discord login, WhatsApp
-     * Baileys boot) — running them sequentially adds 2-5s to cold start with no
-     * coordination benefit.
-     */
-    start(): Promise<void>;
-    /** Stop all channels */
-    stop(): void;
-    /** Get a channel by ID */
-    get(id: string): Channel | undefined;
-    /** Get all registered channels */
-    getAll(): Channel[];
-    /** Broadcast a notification to all channels */
-    broadcastNotify(text: string, urgent?: boolean): Promise<void>;
-    /**
-     * Broadcast a media attachment to every channel that supports it. Used by
-     * the pending-message dispatcher to deliver media queued by
-     * `beecork_send_media` and the `beecork_generate_*` tools — without this,
-     * those tools queue a row whose JSON envelope is never rendered.
-     *
-     * Channels that don't implement broadcastMedia get a sendNotification
-     * fallback so the user at least learns a file was generated.
-     */
-    broadcastMedia(media: MediaAttachment): Promise<void>;
-}

package/dist/channels/registry.js

@@ -1,80 +0,0 @@
-import { logger } from '../util/logger.js';
-/**
- * ChannelRegistry manages the lifecycle of all channels.
- * Channels register themselves, and the registry handles start/stop/broadcast.
- */
-export class ChannelRegistry {
-    channels = new Map();
-    /** Register a channel */
-    register(channel) {
-        if (this.channels.has(channel.id)) {
-            throw new Error(`Channel "${channel.id}" is already registered`);
-        }
-        this.channels.set(channel.id, channel);
-        logger.info(`Channel registered: ${channel.name} (${channel.id})`);
-    }
-    /**
-     * Start all registered channels in parallel. Each channel's start() is an
-     * independent network handshake (Telegram getMe, Discord login, WhatsApp
-     * Baileys boot) — running them sequentially adds 2-5s to cold start with no
-     * coordination benefit.
-     */
-    async start() {
-        await Promise.all(Array.from(this.channels.entries()).map(async ([id, channel]) => {
-            try {
-                await channel.start();
-                logger.info(`Channel started: ${channel.name}`);
-            }
-            catch (err) {
-                logger.error(`Failed to start channel ${id}:`, err);
-            }
-        }));
-    }
-    /** Stop all channels */
-    stop() {
-        for (const [id, channel] of this.channels) {
-            try {
-                channel.stop();
-            }
-            catch (err) {
-                logger.error(`Failed to stop channel ${id}:`, err);
-            }
-        }
-    }
-    /** Get a channel by ID */
-    get(id) {
-        return this.channels.get(id);
-    }
-    /** Get all registered channels */
-    getAll() {
-        return Array.from(this.channels.values());
-    }
-    /** Broadcast a notification to all channels */
-    async broadcastNotify(text, urgent) {
-        await Promise.all(Array.from(this.channels.values()).map((channel) => channel
-            .sendNotification(text, urgent)
-            .catch((err) => logger.warn(`${channel.name} notify failed:`, err))));
-    }
-    /**
-     * Broadcast a media attachment to every channel that supports it. Used by
-     * the pending-message dispatcher to deliver media queued by
-     * `beecork_send_media` and the `beecork_generate_*` tools — without this,
-     * those tools queue a row whose JSON envelope is never rendered.
-     *
-     * Channels that don't implement broadcastMedia get a sendNotification
-     * fallback so the user at least learns a file was generated.
-     */
-    async broadcastMedia(media) {
-        await Promise.all(Array.from(this.channels.values()).map((channel) => {
-            if (channel.broadcastMedia) {
-                return channel
-                    .broadcastMedia(media)
-                    .catch((err) => logger.warn(`${channel.name} broadcastMedia failed:`, err));
-            }
-            const fallback = `📎 Media generated: ${media.filePath}${media.caption ? `\n${media.caption}` : ''}`;
-            return channel
-                .sendNotification(fallback)
-                .catch((err) => logger.warn(`${channel.name} media-fallback notify failed:`, err));
-        }));
-    }
-}

package/dist/channels/send-helpers.d.ts

@@ -1,19 +0,0 @@
-/**
- * Send a tab-prefixed, chunked, retried response through any channel.
- *
- * Each channel just provides:
- *   - sendChunk(text): the platform-specific send call for one chunk
- *   - maxLength:       the platform's per-message limit
- *   - retryLabel:      label for logger (e.g. "telegram-send")
- *
- * Replaces near-identical per-channel implementations that had already
- * drifted in subtle ways (different prefix gates, different retry envelopes).
- */
-export declare function sendChunkedResponse(opts: {
-    text: string;
-    tabName?: string;
-    maxLength: number;
-    retryLabel: string;
-    retryDelays?: number[];
-    sendChunk: (chunk: string) => Promise<unknown>;
-}): Promise<void>;