@intent-systems/nexus 2026.1.5-3

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

@@ -0,0 +1,188 @@
+import { findFenceSpanAt, isSafeFenceBreak, parseFenceSpans, } from "../markdown/fences.js";
+export class EmbeddedBlockChunker {
+    #buffer = "";
+    #chunking;
+    constructor(chunking) {
+        this.#chunking = chunking;
+    }
+    append(text) {
+        if (!text)
+            return;
+        this.#buffer += text;
+    }
+    reset() {
+        this.#buffer = "";
+    }
+    get bufferedText() {
+        return this.#buffer;
+    }
+    hasBuffered() {
+        return this.#buffer.length > 0;
+    }
+    drain(params) {
+        // KNOWN: We cannot split inside fenced code blocks (Markdown breaks + UI glitches).
+        // When forced (maxChars), we close + reopen the fence to keep Markdown valid.
+        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)
+            return;
+        while (this.#buffer.length >= minChars ||
+            (force && this.#buffer.length > 0)) {
+            const breakResult = force && this.#buffer.length <= maxChars
+                ? this.#pickSoftBreakIndex(this.#buffer, 1)
+                : this.#pickBreakIndex(this.#buffer);
+            if (breakResult.index <= 0) {
+                if (force) {
+                    emit(this.#buffer);
+                    this.#buffer = "";
+                }
+                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();
+                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)
+                return;
+            if (this.#buffer.length < maxChars && !force)
+                return;
+        }
+    }
+    #pickSoftBreakIndex(buffer, minCharsOverride) {
+        const minChars = Math.max(1, Math.floor(minCharsOverride ?? this.#chunking.minChars));
+        if (buffer.length < minChars)
+            return { index: -1 };
+        const fenceSpans = parseFenceSpans(buffer);
+        const preference = this.#chunking.breakPreference ?? "paragraph";
+        if (preference === "paragraph") {
+            let paragraphIdx = buffer.indexOf("\n\n");
+            while (paragraphIdx !== -1) {
+                if (paragraphIdx >= minChars &&
+                    isSafeFenceBreak(fenceSpans, paragraphIdx)) {
+                    return { index: paragraphIdx };
+                }
+                paragraphIdx = buffer.indexOf("\n\n", paragraphIdx + 2);
+            }
+        }
+        if (preference === "paragraph" || preference === "newline") {
+            let newlineIdx = buffer.indexOf("\n");
+            while (newlineIdx !== -1) {
+                if (newlineIdx >= minChars &&
+                    isSafeFenceBreak(fenceSpans, newlineIdx)) {
+                    return { index: newlineIdx };
+                }
+                newlineIdx = buffer.indexOf("\n", newlineIdx + 1);
+            }
+        }
+        if (preference !== "newline") {
+            const matches = buffer.matchAll(/[.!?](?=\s|$)/g);
+            let sentenceIdx = -1;
+            for (const match of matches) {
+                const at = match.index ?? -1;
+                if (at < minChars)
+                    continue;
+                const candidate = at + 1;
+                if (isSafeFenceBreak(fenceSpans, candidate)) {
+                    sentenceIdx = candidate;
+                }
+            }
+            if (sentenceIdx >= minChars)
+                return { index: sentenceIdx };
+        }
+        return { index: -1 };
+    }
+    #pickBreakIndex(buffer) {
+        const minChars = Math.max(1, Math.floor(this.#chunking.minChars));
+        const maxChars = Math.max(minChars, Math.floor(this.#chunking.maxChars));
+        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";
+        if (preference === "paragraph") {
+            let paragraphIdx = window.lastIndexOf("\n\n");
+            while (paragraphIdx >= minChars) {
+                if (isSafeFenceBreak(fenceSpans, paragraphIdx)) {
+                    return { index: paragraphIdx };
+                }
+                paragraphIdx = window.lastIndexOf("\n\n", paragraphIdx - 1);
+            }
+        }
+        if (preference === "paragraph" || preference === "newline") {
+            let newlineIdx = window.lastIndexOf("\n");
+            while (newlineIdx >= minChars) {
+                if (isSafeFenceBreak(fenceSpans, newlineIdx)) {
+                    return { index: newlineIdx };
+                }
+                newlineIdx = window.lastIndexOf("\n", newlineIdx - 1);
+            }
+        }
+        if (preference !== "newline") {
+            const matches = window.matchAll(/[.!?](?=\s|$)/g);
+            let sentenceIdx = -1;
+            for (const match of matches) {
+                const at = match.index ?? -1;
+                if (at < minChars)
+                    continue;
+                const candidate = at + 1;
+                if (isSafeFenceBreak(fenceSpans, candidate)) {
+                    sentenceIdx = candidate;
+                }
+            }
+            if (sentenceIdx >= minChars)
+                return { index: sentenceIdx };
+        }
+        for (let i = window.length - 1; i >= minChars; i--) {
+            if (/\s/.test(window[i]) && isSafeFenceBreak(fenceSpans, i)) {
+                return { index: i };
+            }
+        }
+        if (buffer.length >= maxChars) {
+            if (isSafeFenceBreak(fenceSpans, maxChars))
+                return { index: maxChars };
+            const fence = findFenceSpanAt(fenceSpans, maxChars);
+            if (fence) {
+                return {
+                    index: maxChars,
+                    fenceSplit: {
+                        closeFenceLine: `${fence.indent}${fence.marker}`,
+                        reopenFenceLine: fence.openLine,
+                    },
+                };
+            }
+            return { index: maxChars };
+        }
+        return { index: -1 };
+    }
+}
+function stripLeadingNewlines(value) {
+    let i = 0;
+    while (i < value.length && value[i] === "\n")
+        i++;
+    return i > 0 ? value.slice(i) : value;
+}

package/dist/agents/pi-embedded-helpers.js

@@ -0,0 +1,139 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeThinkLevel, } from "../auto-reply/thinking.js";
+import { sanitizeContentBlocksImages } from "./tool-images.js";
+export async function ensureSessionHeader(params) {
+    const file = params.sessionFile;
+    try {
+        await fs.stat(file);
+        return;
+    }
+    catch {
+        // create
+    }
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const sessionVersion = 2;
+    const entry = {
+        type: "session",
+        version: sessionVersion,
+        id: params.sessionId,
+        timestamp: new Date().toISOString(),
+        cwd: params.cwd,
+    };
+    await fs.writeFile(file, `${JSON.stringify(entry)}\n`, "utf-8");
+}
+export async function sanitizeSessionMessagesImages(messages, label) {
+    // We sanitize historical session messages because Anthropic can reject a request
+    // if the transcript contains oversized base64 images (see MAX_IMAGE_DIMENSION_PX).
+    const out = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== "object") {
+            out.push(msg);
+            continue;
+        }
+        const role = msg.role;
+        if (role === "toolResult") {
+            const toolMsg = msg;
+            const content = Array.isArray(toolMsg.content) ? toolMsg.content : [];
+            const nextContent = (await sanitizeContentBlocksImages(content, label));
+            out.push({ ...toolMsg, content: nextContent });
+            continue;
+        }
+        if (role === "user") {
+            const userMsg = msg;
+            const content = userMsg.content;
+            if (Array.isArray(content)) {
+                const nextContent = (await sanitizeContentBlocksImages(content, label));
+                out.push({ ...userMsg, content: nextContent });
+                continue;
+            }
+        }
+        out.push(msg);
+    }
+    return out;
+}
+export function buildBootstrapContextFiles(files) {
+    return files.map((file) => ({
+        path: file.name,
+        content: file.missing
+            ? `[MISSING] Expected at: ${file.path}`
+            : (file.content ?? ""),
+    }));
+}
+export function formatAssistantErrorText(msg) {
+    if (msg.stopReason !== "error")
+        return undefined;
+    const raw = (msg.errorMessage ?? "").trim();
+    if (!raw)
+        return "LLM request failed with an unknown error.";
+    const invalidRequest = raw.match(/"type":"invalid_request_error".*?"message":"([^"]+)"/);
+    if (invalidRequest?.[1]) {
+        return `LLM request rejected: ${invalidRequest[1]}`;
+    }
+    // Keep it short for WhatsApp.
+    return raw.length > 600 ? `${raw.slice(0, 600)}…` : raw;
+}
+export function isRateLimitAssistantError(msg) {
+    if (!msg || msg.stopReason !== "error")
+        return false;
+    const raw = (msg.errorMessage ?? "").toLowerCase();
+    if (!raw)
+        return false;
+    return isRateLimitErrorMessage(raw);
+}
+export function isRateLimitErrorMessage(raw) {
+    const value = raw.toLowerCase();
+    return (/rate[_ ]limit|too many requests|429/.test(value) ||
+        value.includes("exceeded your current quota"));
+}
+export function isAuthErrorMessage(raw) {
+    const value = raw.toLowerCase();
+    if (!value)
+        return false;
+    return (/invalid[_ ]?api[_ ]?key/.test(value) ||
+        value.includes("incorrect api key") ||
+        value.includes("invalid token") ||
+        value.includes("authentication") ||
+        value.includes("unauthorized") ||
+        value.includes("forbidden") ||
+        value.includes("access denied") ||
+        /\b401\b/.test(value) ||
+        /\b403\b/.test(value));
+}
+export function isAuthAssistantError(msg) {
+    if (!msg || msg.stopReason !== "error")
+        return false;
+    return isAuthErrorMessage(msg.errorMessage ?? "");
+}
+function extractSupportedValues(raw) {
+    const match = raw.match(/supported values are:\s*([^\n.]+)/i) ??
+        raw.match(/supported values:\s*([^\n.]+)/i);
+    if (!match?.[1])
+        return [];
+    const fragment = match[1];
+    const quoted = Array.from(fragment.matchAll(/['"]([^'"]+)['"]/g)).map((entry) => entry[1]?.trim());
+    if (quoted.length > 0) {
+        return quoted.filter((entry) => Boolean(entry));
+    }
+    return fragment
+        .split(/,|\band\b/gi)
+        .map((entry) => entry.replace(/^[^a-zA-Z]+|[^a-zA-Z]+$/g, "").trim())
+        .filter(Boolean);
+}
+export function pickFallbackThinkingLevel(params) {
+    const raw = params.message?.trim();
+    if (!raw)
+        return undefined;
+    const supported = extractSupportedValues(raw);
+    if (supported.length === 0)
+        return undefined;
+    for (const entry of supported) {
+        const normalized = normalizeThinkLevel(entry);
+        if (!normalized)
+            continue;
+        if (params.attempted.has(normalized))
+            continue;
+        return normalized;
+    }
+    return undefined;
+}