@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/agents/pi-embedded-block-chunker.js

@@ -6,8 +6,9 @@ export class EmbeddedBlockChunker {
         this.#chunking = chunking;
     }
     append(text) {
-        if (!text)
+        if (!text) {
             return;
+        }
         this.#buffer += text;
     }
     reset() {
@@ -25,8 +26,15 @@ export class EmbeddedBlockChunker {
         const { force, emit } = params;
         const minChars = Math.max(1, Math.floor(this.#chunking.minChars));
         const maxChars = Math.max(minChars, Math.floor(this.#chunking.maxChars));
-        if (this.#buffer.length < minChars && !force)
+        // When flushOnParagraph is set (chunkMode="newline"), eagerly split on \n\n
+        // boundaries regardless of minChars so each paragraph is sent immediately.
+        if (this.#chunking.flushOnParagraph && !force) {
+            this.#drainParagraphs(emit, maxChars);
+            return;
+        }
+        if (this.#buffer.length < minChars && !force) {
             return;
+        }
         if (force && this.#buffer.length <= maxChars) {
             if (this.#buffer.trim().length > 0) {
                 emit(this.#buffer);
@@ -45,44 +53,81 @@ export class EmbeddedBlockChunker {
                 }
                 return;
             }
-            const breakIdx = breakResult.index;
-            let rawChunk = this.#buffer.slice(0, breakIdx);
-            if (rawChunk.trim().length === 0) {
-                this.#buffer = stripLeadingNewlines(this.#buffer.slice(breakIdx)).trimStart();
+            if (!this.#emitBreakResult(breakResult, emit)) {
                 continue;
             }
-            let nextBuffer = this.#buffer.slice(breakIdx);
-            const fenceSplit = breakResult.fenceSplit;
-            if (fenceSplit) {
-                const closeFence = rawChunk.endsWith("\n")
-                    ? `${fenceSplit.closeFenceLine}\n`
-                    : `\n${fenceSplit.closeFenceLine}\n`;
-                rawChunk = `${rawChunk}${closeFence}`;
-                const reopenFence = fenceSplit.reopenFenceLine.endsWith("\n")
-                    ? fenceSplit.reopenFenceLine
-                    : `${fenceSplit.reopenFenceLine}\n`;
-                nextBuffer = `${reopenFence}${nextBuffer}`;
-            }
-            emit(rawChunk);
-            if (fenceSplit) {
-                this.#buffer = nextBuffer;
-            }
-            else {
-                const nextStart = breakIdx < this.#buffer.length && /\s/.test(this.#buffer[breakIdx])
-                    ? breakIdx + 1
-                    : breakIdx;
-                this.#buffer = stripLeadingNewlines(this.#buffer.slice(nextStart));
-            }
-            if (this.#buffer.length < minChars && !force)
+            if (this.#buffer.length < minChars && !force) {
                 return;
-            if (this.#buffer.length < maxChars && !force)
+            }
+            if (this.#buffer.length < maxChars && !force) {
                 return;
+            }
         }
     }
+    /** Eagerly emit complete paragraphs (text before \n\n) regardless of minChars. */
+    #drainParagraphs(emit, maxChars) {
+        while (this.#buffer.length > 0) {
+            const fenceSpans = parseFenceSpans(this.#buffer);
+            const paragraphBreak = findNextParagraphBreak(this.#buffer, fenceSpans);
+            if (!paragraphBreak || paragraphBreak.index > maxChars) {
+                // No paragraph boundary yet (or the next boundary is too far). If the
+                // buffer exceeds maxChars, fall back to normal break logic to avoid
+                // oversized chunks or unbounded accumulation.
+                if (this.#buffer.length >= maxChars) {
+                    const breakResult = this.#pickBreakIndex(this.#buffer, 1);
+                    if (breakResult.index > 0) {
+                        this.#emitBreakResult(breakResult, emit);
+                        continue;
+                    }
+                }
+                return;
+            }
+            const chunk = this.#buffer.slice(0, paragraphBreak.index);
+            if (chunk.trim().length > 0) {
+                emit(chunk);
+            }
+            this.#buffer = stripLeadingNewlines(this.#buffer.slice(paragraphBreak.index + paragraphBreak.length));
+        }
+    }
+    #emitBreakResult(breakResult, emit) {
+        const breakIdx = breakResult.index;
+        if (breakIdx <= 0) {
+            return false;
+        }
+        let rawChunk = this.#buffer.slice(0, breakIdx);
+        if (rawChunk.trim().length === 0) {
+            this.#buffer = stripLeadingNewlines(this.#buffer.slice(breakIdx)).trimStart();
+            return false;
+        }
+        let nextBuffer = this.#buffer.slice(breakIdx);
+        const fenceSplit = breakResult.fenceSplit;
+        if (fenceSplit) {
+            const closeFence = rawChunk.endsWith("\n")
+                ? `${fenceSplit.closeFenceLine}\n`
+                : `\n${fenceSplit.closeFenceLine}\n`;
+            rawChunk = `${rawChunk}${closeFence}`;
+            const reopenFence = fenceSplit.reopenFenceLine.endsWith("\n")
+                ? fenceSplit.reopenFenceLine
+                : `${fenceSplit.reopenFenceLine}\n`;
+            nextBuffer = `${reopenFence}${nextBuffer}`;
+        }
+        emit(rawChunk);
+        if (fenceSplit) {
+            this.#buffer = nextBuffer;
+        }
+        else {
+            const nextStart = breakIdx < this.#buffer.length && /\s/.test(this.#buffer[breakIdx])
+                ? breakIdx + 1
+                : breakIdx;
+            this.#buffer = stripLeadingNewlines(this.#buffer.slice(nextStart));
+        }
+        return true;
+    }
     #pickSoftBreakIndex(buffer, minCharsOverride) {
         const minChars = Math.max(1, Math.floor(minCharsOverride ?? this.#chunking.minChars));
-        if (buffer.length < minChars)
+        if (buffer.length < minChars) {
             return { index: -1 };
+        }
         const fenceSpans = parseFenceSpans(buffer);
         const preference = this.#chunking.breakPreference ?? "paragraph";
         if (preference === "paragraph") {
@@ -90,10 +135,12 @@ export class EmbeddedBlockChunker {
             while (paragraphIdx !== -1) {
                 const candidates = [paragraphIdx, paragraphIdx + 1];
                 for (const candidate of candidates) {
-                    if (candidate < minChars)
+                    if (candidate < minChars) {
                         continue;
-                    if (candidate < 0 || candidate >= buffer.length)
+                    }
+                    if (candidate < 0 || candidate >= buffer.length) {
                         continue;
+                    }
                     if (isSafeFenceBreak(fenceSpans, candidate)) {
                         return { index: candidate };
                     }
@@ -115,23 +162,26 @@ export class EmbeddedBlockChunker {
             let sentenceIdx = -1;
             for (const match of matches) {
                 const at = match.index ?? -1;
-                if (at < minChars)
+                if (at < minChars) {
                     continue;
+                }
                 const candidate = at + 1;
                 if (isSafeFenceBreak(fenceSpans, candidate)) {
                     sentenceIdx = candidate;
                 }
             }
-            if (sentenceIdx >= minChars)
+            if (sentenceIdx >= minChars) {
                 return { index: sentenceIdx };
+            }
         }
         return { index: -1 };
     }
     #pickBreakIndex(buffer, minCharsOverride) {
         const minChars = Math.max(1, Math.floor(minCharsOverride ?? this.#chunking.minChars));
         const maxChars = Math.max(minChars, Math.floor(this.#chunking.maxChars));
-        if (buffer.length < minChars)
+        if (buffer.length < minChars) {
             return { index: -1 };
+        }
         const window = buffer.slice(0, Math.min(maxChars, buffer.length));
         const fenceSpans = parseFenceSpans(buffer);
         const preference = this.#chunking.breakPreference ?? "paragraph";
@@ -140,10 +190,12 @@ export class EmbeddedBlockChunker {
             while (paragraphIdx >= minChars) {
                 const candidates = [paragraphIdx, paragraphIdx + 1];
                 for (const candidate of candidates) {
-                    if (candidate < minChars)
+                    if (candidate < minChars) {
                         continue;
-                    if (candidate < 0 || candidate >= buffer.length)
+                    }
+                    if (candidate < 0 || candidate >= buffer.length) {
                         continue;
+                    }
                     if (isSafeFenceBreak(fenceSpans, candidate)) {
                         return { index: candidate };
                     }
@@ -165,15 +217,17 @@ export class EmbeddedBlockChunker {
             let sentenceIdx = -1;
             for (const match of matches) {
                 const at = match.index ?? -1;
-                if (at < minChars)
+                if (at < minChars) {
                     continue;
+                }
                 const candidate = at + 1;
                 if (isSafeFenceBreak(fenceSpans, candidate)) {
                     sentenceIdx = candidate;
                 }
             }
-            if (sentenceIdx >= minChars)
+            if (sentenceIdx >= minChars) {
                 return { index: sentenceIdx };
+            }
         }
         if (preference === "newline" && buffer.length < maxChars) {
             return { index: -1 };
@@ -184,8 +238,9 @@ export class EmbeddedBlockChunker {
             }
         }
         if (buffer.length >= maxChars) {
-            if (isSafeFenceBreak(fenceSpans, maxChars))
+            if (isSafeFenceBreak(fenceSpans, maxChars)) {
                 return { index: maxChars };
+            }
             const fence = findFenceSpanAt(fenceSpans, maxChars);
             if (fence) {
                 return {
@@ -203,7 +258,27 @@ export class EmbeddedBlockChunker {
 }
 function stripLeadingNewlines(value) {
     let i = 0;
-    while (i < value.length && value[i] === "\n")
+    while (i < value.length && value[i] === "\n") {
         i++;
+    }
     return i > 0 ? value.slice(i) : value;
 }
+function findNextParagraphBreak(buffer, fenceSpans, startIndex = 0) {
+    if (startIndex < 0) {
+        return null;
+    }
+    const re = /\n[\t ]*\n+/g;
+    re.lastIndex = startIndex;
+    let match;
+    while ((match = re.exec(buffer)) !== null) {
+        const index = match.index ?? -1;
+        if (index < 0) {
+            continue;
+        }
+        if (!isSafeFenceBreak(fenceSpans, index)) {
+            continue;
+        }
+        return { index, length: match[0].length };
+    }
+    return null;
+}