@friendlyrobot/discord-pi-agent 0.22.3 → 0.22.4

package/dist/discord-replies.js

@@ -5,10 +5,13 @@ const DISCORD_MESSAGE_LIMIT = 2000;
 const FENCE_OVERHEAD = 8; // \`\`\`\n + \n\`\`\`
 const MAX_CODE_FENCE_CONTENT = DISCORD_MESSAGE_LIMIT - FENCE_OVERHEAD;
 /**
- * Splits text by newlines into chunks that fit within maxSize.
+ * Splits plain text by newlines into chunks that fit within maxSize.
  * Keeps lines intact unless a single line exceeds maxSize.
+ *
+ * Unlike chunkMessage (markdown-aware, token-level), this is for
+ * raw text without markdown structure (e.g. command output).
  */
-function chunkByLines(text, maxSize) {
+function splitPlainTextIntoChunks(text, maxSize) {
     const lines = text.split("\n");
     const chunks = [];
     let current = "";
@@ -126,7 +129,7 @@ export async function sendCommandReply(message, text) {
         }, "command reply skipped, channel not sendable");
         return;
     }
-    const chunks = chunkByLines(text, MAX_CODE_FENCE_CONTENT).map((c) => `\`\`\`\n${c}\n\`\`\``);
+    const chunks = splitPlainTextIntoChunks(text, MAX_CODE_FENCE_CONTENT).map((c) => `\`\`\`\n${c}\n\`\`\``);
     const [firstChunk, ...remainingChunks] = chunks;
     if (!firstChunk) {
         return;

package/dist/message-chunker.d.ts

@@ -3,5 +3,9 @@
  * code blocks, tables, lists, and other block-level elements.
  * Uses marked's lexer to split on token boundaries so no element
  * gets bisected mid-structure.
+ *
+ * Code blocks larger than maxChunkSize are split into smaller
+ * sub-chunks, each wrapped in its own fences, so Discord can
+ * render each chunk as a valid code block.
  */
 export declare function chunkMessage(text: string, maxChunkSize?: number): string[];

package/dist/message-chunker.js

@@ -6,6 +6,10 @@ const SAFE_MESSAGE_LIMIT = 1900;
  * code blocks, tables, lists, and other block-level elements.
  * Uses marked's lexer to split on token boundaries so no element
  * gets bisected mid-structure.
+ *
+ * Code blocks larger than maxChunkSize are split into smaller
+ * sub-chunks, each wrapped in its own fences, so Discord can
+ * render each chunk as a valid code block.
  */
 export function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
     if (text.length <= maxChunkSize) {
@@ -27,12 +31,55 @@ export function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
     };
     for (const token of tokens) {
         const size = token.raw.length;
+        // If adding this token would overflow AND we have existing
+        // tokens in the chunk, flush the current chunk first so the
+        // oversized token starts fresh.
         if (currentSize + size > maxChunkSize && currentTokens.length > 0) {
             flushChunk();
         }
+        // If this single code block token is larger than the Discord
+        // limit, break it into smaller valid code blocks. We use
+        // DISCORD_MESSAGE_LIMIT as the threshold (not maxChunkSize)
+        // so small-chunkSize tests don't accidentally split code
+        // blocks that are fine in practice.
+        if (size > DISCORD_MESSAGE_LIMIT &&
+            token.type === "code" &&
+            currentTokens.length === 0) {
+            const subChunks = splitOversizedCodeBlock(token, maxChunkSize);
+            chunks.push(...subChunks);
+            continue;
+        }
         currentTokens.push(token);
         currentSize += size;
     }
     flushChunk();
     return chunks.map((chunk) => chunk.slice(0, DISCORD_MESSAGE_LIMIT));
 }
+/**
+ * Split an oversized fenced code block into multiple valid
+ * code blocks, each under maxChunkSize. Each sub-chunk gets
+ * its own opening and closing fences with the same language tag.
+ */
+function splitOversizedCodeBlock(token, maxChunkSize) {
+    const lang = token.lang || "";
+    const fenceChar = token.raw.startsWith("```") ? "```" : "~~~";
+    const header = fenceChar + lang;
+    const footer = fenceChar;
+    // Headroom for wrapping fences plus two newlines.
+    const wrapOverhead = header.length + footer.length + 2;
+    const maxBodySize = maxChunkSize - wrapOverhead;
+    if (maxBodySize <= 0) {
+        // Fences alone eat the whole budget; just return the raw token
+        // capped at DISCORD_MESSAGE_LIMIT (handled by the final map).
+        return [token.raw];
+    }
+    const body = token.text;
+    const subChunks = [];
+    let offset = 0;
+    while (offset < body.length) {
+        const segment = body.slice(offset, offset + maxBodySize);
+        subChunks.push([header, segment, footer].join("\n"));
+        offset += maxBodySize;
+    }
+    return subChunks;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.22.3",
+  "version": "0.22.4",
   "description": "Reusable Discord gateway for persistent pi agent sessions",
   "license": "MIT",
   "type": "module",