@gguf/pigbot 0.0.1 → 0.0.2

package/dist/agents/tools/telegram-actions.js

@@ -1,5 +1,6 @@
 import { resolveTelegramReactionLevel } from "../../telegram/reaction-level.js";
-import { deleteMessageTelegram, reactMessageTelegram, sendMessageTelegram, } from "../../telegram/send.js";
+import { deleteMessageTelegram, editMessageTelegram, reactMessageTelegram, sendMessageTelegram, sendStickerTelegram, } from "../../telegram/send.js";
+import { getCacheStats, searchStickers } from "../../telegram/sticker-cache.js";
 import { resolveTelegramToken } from "../../telegram/token.js";
 import { resolveTelegramInlineButtonsScope, resolveTelegramTargetChatType, } from "../../telegram/inline-buttons.js";
 import { createActionGate, jsonResult, readNumberParam, readReactionParams, readStringOrNumberParam, readStringParam, } from "./common.js";
@@ -118,6 +119,7 @@ export async function handleTelegramAction(params, cfg) {
         const messageThreadId = readNumberParam(params, "messageThreadId", {
             integer: true,
         });
+        const quoteText = readStringParam(params, "quoteText");
         const token = resolveTelegramToken(cfg, { accountId }).token;
         if (!token) {
             throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
@@ -129,7 +131,9 @@ export async function handleTelegramAction(params, cfg) {
             buttons,
             replyToMessageId: replyToMessageId ?? undefined,
             messageThreadId: messageThreadId ?? undefined,
+            quoteText: quoteText ?? undefined,
             asVoice: typeof params.asVoice === "boolean" ? params.asVoice : undefined,
+            silent: typeof params.silent === "boolean" ? params.silent : undefined,
         });
         return jsonResult({
             ok: true,
@@ -158,5 +162,95 @@ export async function handleTelegramAction(params, cfg) {
         });
         return jsonResult({ ok: true, deleted: true });
     }
+    if (action === "editMessage") {
+        if (!isActionEnabled("editMessage")) {
+            throw new Error("Telegram editMessage is disabled.");
+        }
+        const chatId = readStringOrNumberParam(params, "chatId", {
+            required: true,
+        });
+        const messageId = readNumberParam(params, "messageId", {
+            required: true,
+            integer: true,
+        });
+        const content = readStringParam(params, "content", {
+            required: true,
+            allowEmpty: false,
+        });
+        const buttons = readTelegramButtons(params);
+        if (buttons) {
+            const inlineButtonsScope = resolveTelegramInlineButtonsScope({
+                cfg,
+                accountId: accountId ?? undefined,
+            });
+            if (inlineButtonsScope === "off") {
+                throw new Error('Telegram inline buttons are disabled. Set channels.telegram.capabilities.inlineButtons to "dm", "group", "all", or "allowlist".');
+            }
+        }
+        const token = resolveTelegramToken(cfg, { accountId }).token;
+        if (!token) {
+            throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+        }
+        const result = await editMessageTelegram(chatId ?? "", messageId ?? 0, content, {
+            token,
+            accountId: accountId ?? undefined,
+            buttons,
+        });
+        return jsonResult({
+            ok: true,
+            messageId: result.messageId,
+            chatId: result.chatId,
+        });
+    }
+    if (action === "sendSticker") {
+        if (!isActionEnabled("sticker", false)) {
+            throw new Error("Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.");
+        }
+        const to = readStringParam(params, "to", { required: true });
+        const fileId = readStringParam(params, "fileId", { required: true });
+        const replyToMessageId = readNumberParam(params, "replyToMessageId", {
+            integer: true,
+        });
+        const messageThreadId = readNumberParam(params, "messageThreadId", {
+            integer: true,
+        });
+        const token = resolveTelegramToken(cfg, { accountId }).token;
+        if (!token) {
+            throw new Error("Telegram bot token missing. Set TELEGRAM_BOT_TOKEN or channels.telegram.botToken.");
+        }
+        const result = await sendStickerTelegram(to, fileId, {
+            token,
+            accountId: accountId ?? undefined,
+            replyToMessageId: replyToMessageId ?? undefined,
+            messageThreadId: messageThreadId ?? undefined,
+        });
+        return jsonResult({
+            ok: true,
+            messageId: result.messageId,
+            chatId: result.chatId,
+        });
+    }
+    if (action === "searchSticker") {
+        if (!isActionEnabled("sticker", false)) {
+            throw new Error("Telegram sticker actions are disabled. Set channels.telegram.actions.sticker to true.");
+        }
+        const query = readStringParam(params, "query", { required: true });
+        const limit = readNumberParam(params, "limit", { integer: true }) ?? 5;
+        const results = searchStickers(query, limit);
+        return jsonResult({
+            ok: true,
+            count: results.length,
+            stickers: results.map((s) => ({
+                fileId: s.fileId,
+                emoji: s.emoji,
+                description: s.description,
+                setName: s.setName,
+            })),
+        });
+    }
+    if (action === "stickerCacheStats") {
+        const stats = getCacheStats();
+        return jsonResult({ ok: true, ...stats });
+    }
     throw new Error(`Unsupported Telegram action: ${action}`);
 }

package/dist/agents/tools/web-fetch.js

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { assertPublicHostname, SsrFBlockedError } from "../../infra/net/ssrf.js";
+import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostname, SsrFBlockedError, } from "../../infra/net/ssrf.js";
 import { stringEnum } from "../schema/typebox.js";
 import { jsonResult, readNumberParam, readStringParam } from "./common.js";
 import { DEFAULT_CACHE_TTL_MINUTES, DEFAULT_TIMEOUT_SECONDS, normalizeCacheKey, readCache, readResponseText, resolveCacheTtlMs, resolveTimeoutSeconds, withTimeout, writeCache, } from "./web-shared.js";
@@ -120,36 +120,49 @@ async function fetchWithRedirects(params) {
         if (!["http:", "https:"].includes(parsedUrl.protocol)) {
             throw new Error("Invalid URL: must be http or https");
         }
-        await assertPublicHostname(parsedUrl.hostname);
-        const res = await fetch(parsedUrl.toString(), {
-            method: "GET",
-            headers: {
-                Accept: "*/*",
-                "User-Agent": params.userAgent,
-                "Accept-Language": "en-US,en;q=0.9",
-            },
-            signal,
-            redirect: "manual",
-        });
+        const pinned = await resolvePinnedHostname(parsedUrl.hostname);
+        const dispatcher = createPinnedDispatcher(pinned);
+        let res;
+        try {
+            res = await fetch(parsedUrl.toString(), {
+                method: "GET",
+                headers: {
+                    Accept: "*/*",
+                    "User-Agent": params.userAgent,
+                    "Accept-Language": "en-US,en;q=0.9",
+                },
+                signal,
+                redirect: "manual",
+                dispatcher,
+            });
+        }
+        catch (err) {
+            await closeDispatcher(dispatcher);
+            throw err;
+        }
         if (isRedirectStatus(res.status)) {
             const location = res.headers.get("location");
             if (!location) {
+                await closeDispatcher(dispatcher);
                 throw new Error(`Redirect missing location header (${res.status})`);
             }
             redirectCount += 1;
             if (redirectCount > params.maxRedirects) {
+                await closeDispatcher(dispatcher);
                 throw new Error(`Too many redirects (limit: ${params.maxRedirects})`);
             }
             const nextUrl = new URL(location, parsedUrl).toString();
             if (visited.has(nextUrl)) {
+                await closeDispatcher(dispatcher);
                 throw new Error("Redirect loop detected");
             }
             visited.add(nextUrl);
             void res.body?.cancel();
+            await closeDispatcher(dispatcher);
             currentUrl = nextUrl;
             continue;
         }
-        return { response: res, finalUrl: currentUrl };
+        return { response: res, finalUrl: currentUrl, dispatcher };
     }
 }
 function formatWebFetchErrorDetail(params) {
@@ -223,6 +236,7 @@ async function runWebFetch(params) {
     }
     const start = Date.now();
     let res;
+    let dispatcher = null;
     let finalUrl = params.url;
     try {
         const result = await fetchWithRedirects({
@@ -233,6 +247,7 @@ async function runWebFetch(params) {
         });
         res = result.response;
         finalUrl = result.finalUrl;
+        dispatcher = result.dispatcher;
     }
     catch (error) {
         if (error instanceof SsrFBlockedError) {
@@ -271,106 +286,111 @@ async function runWebFetch(params) {
         }
         throw error;
     }
-    if (!res.ok) {
-        if (params.firecrawlEnabled && params.firecrawlApiKey) {
-            const firecrawl = await fetchFirecrawlContent({
-                url: params.url,
-                extractMode: params.extractMode,
-                apiKey: params.firecrawlApiKey,
-                baseUrl: params.firecrawlBaseUrl,
-                onlyMainContent: params.firecrawlOnlyMainContent,
-                maxAgeMs: params.firecrawlMaxAgeMs,
-                proxy: params.firecrawlProxy,
-                storeInCache: params.firecrawlStoreInCache,
-                timeoutSeconds: params.firecrawlTimeoutSeconds,
+    try {
+        if (!res.ok) {
+            if (params.firecrawlEnabled && params.firecrawlApiKey) {
+                const firecrawl = await fetchFirecrawlContent({
+                    url: params.url,
+                    extractMode: params.extractMode,
+                    apiKey: params.firecrawlApiKey,
+                    baseUrl: params.firecrawlBaseUrl,
+                    onlyMainContent: params.firecrawlOnlyMainContent,
+                    maxAgeMs: params.firecrawlMaxAgeMs,
+                    proxy: params.firecrawlProxy,
+                    storeInCache: params.firecrawlStoreInCache,
+                    timeoutSeconds: params.firecrawlTimeoutSeconds,
+                });
+                const truncated = truncateText(firecrawl.text, params.maxChars);
+                const payload = {
+                    url: params.url,
+                    finalUrl: firecrawl.finalUrl || finalUrl,
+                    status: firecrawl.status ?? res.status,
+                    contentType: "text/markdown",
+                    title: firecrawl.title,
+                    extractMode: params.extractMode,
+                    extractor: "firecrawl",
+                    truncated: truncated.truncated,
+                    length: truncated.text.length,
+                    fetchedAt: new Date().toISOString(),
+                    tookMs: Date.now() - start,
+                    text: truncated.text,
+                    warning: firecrawl.warning,
+                };
+                writeCache(FETCH_CACHE, cacheKey, payload, params.cacheTtlMs);
+                return payload;
+            }
+            const rawDetail = await readResponseText(res);
+            const detail = formatWebFetchErrorDetail({
+                detail: rawDetail,
+                contentType: res.headers.get("content-type"),
+                maxChars: DEFAULT_ERROR_MAX_CHARS,
             });
-            const truncated = truncateText(firecrawl.text, params.maxChars);
-            const payload = {
-                url: params.url,
-                finalUrl: firecrawl.finalUrl || finalUrl,
-                status: firecrawl.status ?? res.status,
-                contentType: "text/markdown",
-                title: firecrawl.title,
-                extractMode: params.extractMode,
-                extractor: "firecrawl",
-                truncated: truncated.truncated,
-                length: truncated.text.length,
-                fetchedAt: new Date().toISOString(),
-                tookMs: Date.now() - start,
-                text: truncated.text,
-                warning: firecrawl.warning,
-            };
-            writeCache(FETCH_CACHE, cacheKey, payload, params.cacheTtlMs);
-            return payload;
+            throw new Error(`Web fetch failed (${res.status}): ${detail || res.statusText}`);
         }
-        const rawDetail = await readResponseText(res);
-        const detail = formatWebFetchErrorDetail({
-            detail: rawDetail,
-            contentType: res.headers.get("content-type"),
-            maxChars: DEFAULT_ERROR_MAX_CHARS,
-        });
-        throw new Error(`Web fetch failed (${res.status}): ${detail || res.statusText}`);
-    }
-    const contentType = res.headers.get("content-type") ?? "application/octet-stream";
-    const body = await readResponseText(res);
-    let title;
-    let extractor = "raw";
-    let text = body;
-    if (contentType.includes("text/html")) {
-        if (params.readabilityEnabled) {
-            const readable = await extractReadableContent({
-                html: body,
-                url: finalUrl,
-                extractMode: params.extractMode,
-            });
-            if (readable?.text) {
-                text = readable.text;
-                title = readable.title;
-                extractor = "readability";
-            }
-            else {
-                const firecrawl = await tryFirecrawlFallback({ ...params, url: finalUrl });
-                if (firecrawl) {
-                    text = firecrawl.text;
-                    title = firecrawl.title;
-                    extractor = "firecrawl";
+        const contentType = res.headers.get("content-type") ?? "application/octet-stream";
+        const body = await readResponseText(res);
+        let title;
+        let extractor = "raw";
+        let text = body;
+        if (contentType.includes("text/html")) {
+            if (params.readabilityEnabled) {
+                const readable = await extractReadableContent({
+                    html: body,
+                    url: finalUrl,
+                    extractMode: params.extractMode,
+                });
+                if (readable?.text) {
+                    text = readable.text;
+                    title = readable.title;
+                    extractor = "readability";
                 }
                 else {
-                    throw new Error("Web fetch extraction failed: Readability and Firecrawl returned no content.");
+                    const firecrawl = await tryFirecrawlFallback({ ...params, url: finalUrl });
+                    if (firecrawl) {
+                        text = firecrawl.text;
+                        title = firecrawl.title;
+                        extractor = "firecrawl";
+                    }
+                    else {
+                        throw new Error("Web fetch extraction failed: Readability and Firecrawl returned no content.");
+                    }
                 }
             }
+            else {
+                throw new Error("Web fetch extraction failed: Readability disabled and Firecrawl unavailable.");
+            }
         }
-        else {
-            throw new Error("Web fetch extraction failed: Readability disabled and Firecrawl unavailable.");
+        else if (contentType.includes("application/json")) {
+            try {
+                text = JSON.stringify(JSON.parse(body), null, 2);
+                extractor = "json";
+            }
+            catch {
+                text = body;
+                extractor = "raw";
+            }
         }
+        const truncated = truncateText(text, params.maxChars);
+        const payload = {
+            url: params.url,
+            finalUrl,
+            status: res.status,
+            contentType,
+            title,
+            extractMode: params.extractMode,
+            extractor,
+            truncated: truncated.truncated,
+            length: truncated.text.length,
+            fetchedAt: new Date().toISOString(),
+            tookMs: Date.now() - start,
+            text: truncated.text,
+        };
+        writeCache(FETCH_CACHE, cacheKey, payload, params.cacheTtlMs);
+        return payload;
     }
-    else if (contentType.includes("application/json")) {
-        try {
-            text = JSON.stringify(JSON.parse(body), null, 2);
-            extractor = "json";
-        }
-        catch {
-            text = body;
-            extractor = "raw";
-        }
+    finally {
+        await closeDispatcher(dispatcher);
     }
-    const truncated = truncateText(text, params.maxChars);
-    const payload = {
-        url: params.url,
-        finalUrl,
-        status: res.status,
-        contentType,
-        title,
-        extractMode: params.extractMode,
-        extractor,
-        truncated: truncated.truncated,
-        length: truncated.text.length,
-        fetchedAt: new Date().toISOString(),
-        tookMs: Date.now() - start,
-        text: truncated.text,
-    };
-    writeCache(FETCH_CACHE, cacheKey, payload, params.cacheTtlMs);
-    return payload;
 }
 async function tryFirecrawlFallback(params) {
     if (!params.firecrawlEnabled || !params.firecrawlApiKey)

package/dist/agents/tools/web-search.js

@@ -57,13 +57,13 @@ function missingSearchKeyPayload(provider) {
         return {
             error: "missing_perplexity_api_key",
             message: "web_search (perplexity) needs an API key. Set PERPLEXITY_API_KEY or OPENROUTER_API_KEY in the Gateway environment, or configure tools.web.search.perplexity.apiKey.",
-            docs: "https://docs.clawd.bot/tools/web",
+            docs: "https://docs.molt.bot/tools/web",
         };
     }
     return {
         error: "missing_brave_api_key",
-        message: `web_search needs a Brave Search API key. Run \`${formatCliCommand("pigbot configure --section web")}\` to store it, or set BRAVE_API_KEY in the Gateway environment.`,
-        docs: "https://docs.clawd.bot/tools/web",
+        message: `web_search needs a Brave Search API key. Run \`${formatCliCommand("moltbot configure --section web")}\` to store it, or set BRAVE_API_KEY in the Gateway environment.`,
+        docs: "https://docs.molt.bot/tools/web",
     };
 }
 function resolveSearchProvider(search) {
@@ -189,8 +189,8 @@ async function runPerplexitySearch(params) {
         headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${params.apiKey}`,
-            "HTTP-Referer": "https://pigbot.com",
-            "X-Title": "Pigbot Web Search",
+            "HTTP-Referer": "https://molt.bot",
+            "X-Title": "Moltbot Web Search",
         },
         body: JSON.stringify({
             model: params.model,
@@ -319,7 +319,7 @@ export function createWebSearchTool(options) {
                 return jsonResult({
                     error: "unsupported_freshness",
                     message: "freshness is only supported by the Brave web_search provider.",
-                    docs: "https://docs.clawd.bot/tools/web",
+                    docs: "https://docs.molt.bot/tools/web",
                 });
             }
             const freshness = rawFreshness ? normalizeFreshness(rawFreshness) : undefined;
@@ -327,7 +327,7 @@ export function createWebSearchTool(options) {
                 return jsonResult({
                     error: "invalid_freshness",
                     message: "freshness must be one of pd, pw, pm, py, or a range like YYYY-MM-DDtoYYYY-MM-DD.",
-                    docs: "https://docs.clawd.bot/tools/web",
+                    docs: "https://docs.molt.bot/tools/web",
                 });
             }
             const result = await runWebSearch({

package/dist/agents/workspace.js

@@ -6,7 +6,7 @@ import { isSubagentSessionKey } from "../routing/session-key.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { resolveUserPath } from "../utils.js";
 export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
-    const profile = env.PIGBOT_PROFILE?.trim();
+    const profile = env.CLAWDBOT_PROFILE?.trim();
     if (profile && profile.toLowerCase() !== "default") {
         return path.join(homedir(), `clawd-${profile}`);
     }
@@ -20,6 +20,8 @@ export const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
 export const DEFAULT_USER_FILENAME = "USER.md";
 export const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
 export const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
+export const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+export const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
 const TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/reference/templates");
 function stripFrontMatter(content) {
     if (!content.startsWith("---"))
@@ -141,6 +143,39 @@ export async function ensureAgentWorkspace(params) {
         bootstrapPath,
     };
 }
+async function resolveMemoryBootstrapEntries(resolvedDir) {
+    const candidates = [
+        DEFAULT_MEMORY_FILENAME,
+        DEFAULT_MEMORY_ALT_FILENAME,
+    ];
+    const entries = [];
+    for (const name of candidates) {
+        const filePath = path.join(resolvedDir, name);
+        try {
+            await fs.access(filePath);
+            entries.push({ name, filePath });
+        }
+        catch {
+            // optional
+        }
+    }
+    if (entries.length <= 1)
+        return entries;
+    const seen = new Set();
+    const deduped = [];
+    for (const entry of entries) {
+        let key = entry.filePath;
+        try {
+            key = await fs.realpath(entry.filePath);
+        }
+        catch { }
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(entry);
+    }
+    return deduped;
+}
 export async function loadWorkspaceBootstrapFiles(dir) {
     const resolvedDir = resolveUserPath(dir);
     const entries = [
@@ -173,6 +208,7 @@ export async function loadWorkspaceBootstrapFiles(dir) {
             filePath: path.join(resolvedDir, DEFAULT_BOOTSTRAP_FILENAME),
         },
     ];
+    entries.push(...(await resolveMemoryBootstrapEntries(resolvedDir)));
     const result = [];
     for (const entry of entries) {
         try {

package/dist/auto-reply/chunk.js

@@ -111,43 +111,88 @@ export function chunkByNewline(text, maxLineLength, opts) {
     }
     return chunks;
 }
+/**
+ * Split text into chunks on paragraph boundaries (blank lines), preserving lists and
+ * single-newline line wraps inside paragraphs.
+ *
+ * - Only breaks at paragraph separators ("\n\n" or more, allowing whitespace on blank lines)
+ * - Packs multiple paragraphs into a single chunk up to `limit`
+ * - Falls back to length-based splitting when a single paragraph exceeds `limit`
+ *   (unless `splitLongParagraphs` is disabled)
+ */
+export function chunkByParagraph(text, limit, opts) {
+    if (!text)
+        return [];
+    if (limit <= 0)
+        return [text];
+    const splitLongParagraphs = opts?.splitLongParagraphs !== false;
+    // Normalize to \n so blank line detection is consistent.
+    const normalized = text.replace(/\r\n?/g, "\n");
+    // Fast-path: if there are no blank-line paragraph separators, do not split.
+    // (We *do not* early-return based on `limit` — newline mode is about paragraph
+    // boundaries, not only exceeding a length limit.)
+    const paragraphRe = /\n[\t ]*\n+/;
+    if (!paragraphRe.test(normalized)) {
+        if (normalized.length <= limit)
+            return [normalized];
+        if (!splitLongParagraphs)
+            return [normalized];
+        return chunkText(normalized, limit);
+    }
+    const spans = parseFenceSpans(normalized);
+    const parts = [];
+    const re = /\n[\t ]*\n+/g; // paragraph break: blank line(s), allowing whitespace
+    let lastIndex = 0;
+    for (const match of normalized.matchAll(re)) {
+        const idx = match.index ?? 0;
+        // Do not split on blank lines that occur inside fenced code blocks.
+        if (!isSafeFenceBreak(spans, idx)) {
+            continue;
+        }
+        parts.push(normalized.slice(lastIndex, idx));
+        lastIndex = idx + match[0].length;
+    }
+    parts.push(normalized.slice(lastIndex));
+    const chunks = [];
+    for (const part of parts) {
+        const paragraph = part.replace(/\s+$/g, "");
+        if (!paragraph.trim())
+            continue;
+        if (paragraph.length <= limit) {
+            chunks.push(paragraph);
+        }
+        else if (!splitLongParagraphs) {
+            chunks.push(paragraph);
+        }
+        else {
+            chunks.push(...chunkText(paragraph, limit));
+        }
+    }
+    return chunks;
+}
 /**
  * Unified chunking function that dispatches based on mode.
  */
 export function chunkTextWithMode(text, limit, mode) {
     if (mode === "newline") {
-        const chunks = [];
-        const lineChunks = chunkByNewline(text, limit, { splitLongLines: false });
-        for (const line of lineChunks) {
-            const nested = chunkText(line, limit);
-            if (!nested.length && line) {
-                chunks.push(line);
-                continue;
-            }
-            chunks.push(...nested);
-        }
-        return chunks;
+        return chunkByParagraph(text, limit);
     }
     return chunkText(text, limit);
 }
 export function chunkMarkdownTextWithMode(text, limit, mode) {
     if (mode === "newline") {
-        const spans = parseFenceSpans(text);
-        const chunks = [];
-        const lineChunks = chunkByNewline(text, limit, {
-            splitLongLines: false,
-            trimLines: false,
-            isSafeBreak: (index) => isSafeFenceBreak(spans, index),
-        });
-        for (const line of lineChunks) {
-            const nested = chunkMarkdownText(line, limit);
-            if (!nested.length && line) {
-                chunks.push(line);
-                continue;
-            }
-            chunks.push(...nested);
+        // Paragraph chunking is fence-safe because we never split at arbitrary indices.
+        // If a paragraph must be split by length, defer to the markdown-aware chunker.
+        const paragraphChunks = chunkByParagraph(text, limit, { splitLongParagraphs: false });
+        const out = [];
+        for (const chunk of paragraphChunks) {
+            const nested = chunkMarkdownText(chunk, limit);
+            if (!nested.length && chunk)
+                out.push(chunk);
+            else
+                out.push(...nested);
         }
-        return chunks;
+        return out;
     }
     return chunkMarkdownText(text, limit);
 }