agent-sh 0.8.0 → 0.10.0

package/dist/agent/tool-protocol.js

@@ -0,0 +1,551 @@
+// ── API mode (current behavior) ──────────────────────────────────
+export class ApiToolProtocol {
+    mode = "api";
+    getApiTools(tools) {
+        if (tools.length === 0)
+            return undefined;
+        return tools.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.input_schema,
+            },
+        }));
+    }
+    getToolPrompt() {
+        return "";
+    }
+    extractToolCalls(_text, streamedCalls) {
+        return streamedCalls;
+    }
+    rewriteToolCall(tc) {
+        return tc;
+    }
+    recordAssistant(conv, text, toolCalls) {
+        const calls = toolCalls.length
+            ? toolCalls.map((tc) => ({
+                id: tc.id,
+                function: { name: tc.name, arguments: tc.argumentsJson },
+            }))
+            : undefined;
+        conv.addAssistantMessage(text || null, calls);
+    }
+    recordResults(conv, results) {
+        for (const r of results) {
+            const content = r.isError ? `Error: ${r.content}` : r.content;
+            conv.addToolResult(r.callId, content, r.isError);
+        }
+    }
+    createStreamFilter() {
+        return null;
+    }
+}
+// ── Inline mode (JSON code block tool calls) ─────────────────────
+export class InlineToolProtocol {
+    mode = "inline";
+    callCounter = 0;
+    getApiTools() {
+        return undefined;
+    }
+    getToolPrompt(tools) {
+        if (tools.length === 0)
+            return "";
+        const lines = [
+            "",
+            "# Tools",
+            "",
+            "To call a tool, write a ```tool fenced block with JSON:",
+            "",
+            "```tool",
+            '{"tool": "grep", "pattern": "TODO", "path": "src/"}',
+            "```",
+            "",
+            "The `tool` field selects which tool. All other fields are arguments.",
+            "Multiple tool blocks allowed per response.",
+            "",
+            "Available: " + tools.map((t) => `${t.name}${formatParams(t.input_schema)}`).join(", "),
+        ];
+        return lines.join("\n");
+    }
+    rewriteToolCall(tc) {
+        return tc;
+    }
+    extractToolCalls(text, _streamedCalls) {
+        const calls = [];
+        // Match ```tool ... ``` blocks
+        const regex = /```tool\s*\n([\s\S]*?)```/g;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            const body = match[1].trim();
+            try {
+                const obj = JSON.parse(body);
+                const name = obj.tool;
+                if (typeof name !== "string")
+                    continue;
+                // Separate tool name from args
+                const { tool: _, ...args } = obj;
+                calls.push({
+                    id: `inline_${++this.callCounter}`,
+                    name,
+                    argumentsJson: JSON.stringify(args),
+                });
+            }
+            catch {
+                // Not valid JSON — skip
+            }
+        }
+        return calls;
+    }
+    recordAssistant(conv, text, _toolCalls) {
+        conv.addAssistantMessage(text || null);
+    }
+    recordResults(conv, results) {
+        if (results.length === 0)
+            return;
+        const parts = results.map((r) => {
+            const status = r.isError ? "error" : "ok";
+            return `[${r.toolName} ${r.callId} ${status}]\n${r.content}`;
+        });
+        conv.addToolResultInline(parts.join("\n\n"));
+    }
+    createStreamFilter(_toolNames) {
+        return new CodeBlockFilter();
+    }
+}
+// ── Code block stream filter ────────────────────────────────────
+/**
+ * Strips ```tool ... ``` blocks from streamed text.
+ * Simple state machine: normal → in_fence → normal.
+ */
+class CodeBlockFilter {
+    buf = "";
+    inFence = false;
+    lastEmittedNewlines = 0; // track trailing newlines to collapse blanks
+    feed(chunk) {
+        this.buf += chunk;
+        let raw = "";
+        while (this.buf.length > 0) {
+            if (this.inFence) {
+                // Look for closing ```
+                const closeIdx = this.buf.indexOf("```");
+                if (closeIdx !== -1) {
+                    // Skip past closing ``` and any trailing whitespace on that line
+                    let end = closeIdx + 3;
+                    while (end < this.buf.length && this.buf[end] === "\n")
+                        end++;
+                    this.buf = this.buf.slice(end);
+                    this.inFence = false;
+                    continue;
+                }
+                // No closing yet — keep buffering
+                break;
+            }
+            // Look for opening ```tool
+            const openIdx = this.buf.indexOf("```tool");
+            if (openIdx !== -1) {
+                // Emit everything before the fence, trimming trailing newline
+                let before = this.buf.slice(0, openIdx);
+                if (before.endsWith("\n"))
+                    before = before.slice(0, -1);
+                raw += before;
+                this.buf = this.buf.slice(openIdx + 7); // skip ```tool
+                this.inFence = true;
+                continue;
+            }
+            // Stray ``` on its own line (residual closing fence)
+            const strayIdx = this.buf.indexOf("```");
+            if (strayIdx !== -1) {
+                // Check if it's just backticks on a line (possibly with whitespace)
+                const lineStart = this.buf.lastIndexOf("\n", strayIdx - 1) + 1;
+                const lineEnd = this.buf.indexOf("\n", strayIdx);
+                const line = this.buf.slice(lineStart, lineEnd === -1 ? undefined : lineEnd).trim();
+                if (line === "```") {
+                    raw += this.buf.slice(0, lineStart);
+                    this.buf = this.buf.slice(lineEnd === -1 ? this.buf.length : lineEnd + 1);
+                    continue;
+                }
+            }
+            // Could be a partial match at the end
+            const marker = "```tool";
+            let partial = false;
+            for (let i = Math.min(marker.length - 1, this.buf.length); i >= 1; i--) {
+                if (this.buf.endsWith(marker.slice(0, i))) {
+                    raw += this.buf.slice(0, this.buf.length - i);
+                    this.buf = this.buf.slice(this.buf.length - i);
+                    partial = true;
+                    break;
+                }
+            }
+            if (partial)
+                break;
+            // No fence anywhere — emit all
+            raw += this.buf;
+            this.buf = "";
+        }
+        // Collapse runs of 3+ newlines into 2 (one blank line max)
+        return this.collapseNewlines(raw);
+    }
+    flush() {
+        const out = this.collapseNewlines(this.buf);
+        this.buf = "";
+        this.inFence = false;
+        return out;
+    }
+    collapseNewlines(text) {
+        if (!text)
+            return text;
+        // Count leading newlines and merge with trailing from last emit
+        let i = 0;
+        while (i < text.length && text[i] === "\n")
+            i++;
+        const leading = i;
+        const totalNewlines = this.lastEmittedNewlines + leading;
+        // Allow at most 2 consecutive newlines
+        let prefix = "";
+        if (leading > 0) {
+            const allowed = Math.max(0, 2 - this.lastEmittedNewlines);
+            prefix = "\n".repeat(Math.min(leading, allowed));
+            text = text.slice(leading);
+        }
+        // Collapse internal runs
+        text = text.replace(/\n{3,}/g, "\n\n");
+        // Track trailing newlines for next call
+        let trailing = 0;
+        let j = text.length;
+        while (j > 0 && text[j - 1] === "\n") {
+            j--;
+            trailing++;
+        }
+        this.lastEmittedNewlines = trailing > 0 ? trailing : (prefix ? totalNewlines - leading + prefix.length : 0);
+        return prefix + text;
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function formatParams(schema) {
+    const props = schema.properties;
+    if (!props || Object.keys(props).length === 0)
+        return "()";
+    const required = new Set(schema.required ?? []);
+    const params = Object.entries(props).map(([name, prop]) => {
+        const opt = required.has(name) ? "" : "?";
+        const enumVals = prop.enum;
+        if (enumVals)
+            return `${name}${opt}: ${enumVals.join("|")}`;
+        return `${name}${opt}`;
+    });
+    return `(${params.join(", ")})`;
+}
+// ── Deferred mode (core tools full schema, extensions via meta-tool) ──
+const META_TOOL_NAME = "use_extension";
+export class DeferredToolProtocol {
+    mode = "deferred";
+    coreNames;
+    /** Cached extension tool schemas for arg validation. */
+    extSchemas = new Map();
+    constructor(coreNames) {
+        this.coreNames = new Set(coreNames);
+    }
+    getApiTools(tools) {
+        const core = tools.filter((t) => this.coreNames.has(t.name));
+        const ext = tools.filter((t) => !this.coreNames.has(t.name));
+        // Cache extension schemas for validation in rewriteToolCall
+        this.extSchemas.clear();
+        for (const t of ext) {
+            this.extSchemas.set(t.name, t.input_schema);
+        }
+        const apiTools = core.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.input_schema,
+            },
+        }));
+        if (ext.length > 0) {
+            const catalog = ext
+                .map((t) => `${t.name}${formatParams(t.input_schema)}`)
+                .join(", ");
+            apiTools.push({
+                type: "function",
+                function: {
+                    name: META_TOOL_NAME,
+                    description: `Call an extension tool. Available: ${catalog}`,
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string", description: "Tool name to call" },
+                            args: {
+                                type: "object",
+                                description: "Tool arguments",
+                                properties: {},
+                                additionalProperties: true,
+                            },
+                        },
+                        required: ["name"],
+                    },
+                },
+            });
+        }
+        return apiTools.length > 0 ? apiTools : undefined;
+    }
+    getToolPrompt() {
+        return "";
+    }
+    extractToolCalls(_text, streamedCalls) {
+        return streamedCalls;
+    }
+    rewriteToolCall(tc) {
+        if (tc.name !== META_TOOL_NAME)
+            return tc;
+        // Unwrap: use_extension(name="foo", args={...}) → foo({...})
+        try {
+            const parsed = JSON.parse(tc.argumentsJson);
+            const targetName = parsed.name;
+            const targetArgs = (parsed.args ?? {});
+            // Validate: does the extension exist?
+            const schema = this.extSchemas.get(targetName);
+            if (!schema) {
+                const available = [...this.extSchemas.keys()].join(", ");
+                return {
+                    id: tc.id,
+                    name: META_TOOL_NAME,
+                    argumentsJson: JSON.stringify({
+                        _error: `Unknown extension "${targetName}". Available: ${available}`,
+                    }),
+                };
+            }
+            // Validate: check for unknown/missing params against schema
+            const schemaProps = schema.properties;
+            const requiredParams = new Set(schema.required ?? []);
+            if (schemaProps) {
+                const validParams = new Set(Object.keys(schemaProps));
+                const providedParams = Object.keys(targetArgs);
+                // Check for unknown params (likely wrong names)
+                const unknown = providedParams.filter((p) => !validParams.has(p));
+                // Check for missing required params
+                const missing = [...requiredParams].filter((p) => !targetArgs[p]);
+                if (unknown.length > 0 || missing.length > 0) {
+                    const expected = [...validParams]
+                        .map((p) => `${p}${requiredParams.has(p) ? " (required)" : ""}`)
+                        .join(", ");
+                    let hint = `Wrong arguments for "${targetName}". Expected params: ${expected}.`;
+                    if (unknown.length > 0)
+                        hint += ` Unknown: ${unknown.join(", ")}.`;
+                    if (missing.length > 0)
+                        hint += ` Missing: ${missing.join(", ")}.`;
+                    return {
+                        id: tc.id,
+                        name: META_TOOL_NAME,
+                        argumentsJson: JSON.stringify({ _error: hint }),
+                    };
+                }
+            }
+            return {
+                id: tc.id,
+                name: targetName,
+                argumentsJson: JSON.stringify(targetArgs),
+            };
+        }
+        catch {
+            return tc; // Let it fail naturally downstream
+        }
+    }
+    recordAssistant(conv, text, toolCalls) {
+        const calls = toolCalls.length
+            ? toolCalls.map((tc) => ({
+                id: tc.id,
+                function: { name: tc.name, arguments: tc.argumentsJson },
+            }))
+            : undefined;
+        conv.addAssistantMessage(text || null, calls);
+    }
+    recordResults(conv, results) {
+        for (const r of results) {
+            const content = r.isError ? `Error: ${r.content}` : r.content;
+            conv.addToolResult(r.callId, content, r.isError);
+        }
+    }
+    createStreamFilter() {
+        return null;
+    }
+}
+// ── Deferred-lookup mode (load-on-demand with full schema) ──────
+//
+// Like deferred, but instead of wrapping extension calls through a meta-
+// tool dispatcher, we expose a `load_tool` meta-tool that returns the
+// full schema as a tool result AND mutates the protocol's loaded set.
+// Loaded tools become first-class on the NEXT LLM call — the model calls
+// them natively with complete schema fidelity. One round-trip per group
+// of tools loaded, not per call. Prevents the whole class of bugs where
+// models guess arg names from a schema they can only see partially.
+export class DeferredLookupProtocol {
+    mode = "deferred-lookup";
+    coreNames;
+    loadedExt = new Set();
+    /** Cache of the current tools list so load_tool's execute can find schemas. */
+    toolsRef = [];
+    constructor(coreNames) {
+        this.coreNames = new Set(coreNames);
+    }
+    getApiTools(tools) {
+        this.toolsRef = tools;
+        const visible = [];
+        const unloadedExt = [];
+        for (const t of tools) {
+            if (t.name === "load_tool")
+                continue; // rebuilt below with fresh catalog
+            const isCore = this.coreNames.has(t.name);
+            const isLoaded = this.loadedExt.has(t.name);
+            if (isCore || isLoaded) {
+                visible.push({
+                    type: "function",
+                    function: {
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.input_schema,
+                    },
+                });
+            }
+            else {
+                unloadedExt.push(t.name);
+            }
+        }
+        if (unloadedExt.length > 0) {
+            visible.push({
+                type: "function",
+                function: {
+                    name: "load_tool",
+                    description: `Load extension tool schemas so you can call them on the next turn. ` +
+                        `Unloaded: ${unloadedExt.join(", ")}. ` +
+                        `After load_tool succeeds, call those tools directly — not through load_tool again.`,
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            names: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Names of extension tools to load.",
+                            },
+                        },
+                        required: ["names"],
+                    },
+                },
+            });
+        }
+        return visible.length > 0 ? visible : undefined;
+    }
+    getToolPrompt() {
+        return "";
+    }
+    extractToolCalls(_text, streamedCalls) {
+        return streamedCalls;
+    }
+    rewriteToolCall(tc) {
+        return tc; // no dispatching needed — load_tool is a real registered tool
+    }
+    recordAssistant(conv, text, toolCalls) {
+        const calls = toolCalls.length
+            ? toolCalls.map((tc) => ({
+                id: tc.id,
+                function: { name: tc.name, arguments: tc.argumentsJson },
+            }))
+            : undefined;
+        conv.addAssistantMessage(text || null, calls);
+    }
+    recordResults(conv, results) {
+        for (const r of results) {
+            const content = r.isError ? `Error: ${r.content}` : r.content;
+            conv.addToolResult(r.callId, content, r.isError);
+        }
+    }
+    createStreamFilter() {
+        return null;
+    }
+    getProtocolTools() {
+        // load_tool is registered as a real tool so the executor can run it
+        // through the normal dispatch path. Its execute closes over the protocol
+        // instance to mutate the loadedExt set and return schemas.
+        const self = this;
+        return [
+            {
+                name: "load_tool",
+                description: "Load extension tool schemas so you can call them natively on the next turn.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        names: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Names of extension tools to load.",
+                        },
+                    },
+                    required: ["names"],
+                },
+                showOutput: false,
+                async execute(args) {
+                    const names = Array.isArray(args.names) ? args.names : [];
+                    if (names.length === 0) {
+                        return { content: "No tool names provided. Pass { names: [...] }.", exitCode: 1, isError: true };
+                    }
+                    const loaded = [];
+                    const alreadyLoaded = [];
+                    const errors = [];
+                    const sections = [];
+                    for (const name of names) {
+                        const tool = self.toolsRef.find((t) => t.name === name);
+                        if (!tool) {
+                            errors.push(`Unknown tool: ${name}`);
+                            continue;
+                        }
+                        if (self.coreNames.has(name) || name === "load_tool") {
+                            errors.push(`${name} is already available — no need to load.`);
+                            continue;
+                        }
+                        if (self.loadedExt.has(name)) {
+                            alreadyLoaded.push(name);
+                            continue;
+                        }
+                        self.loadedExt.add(name);
+                        loaded.push(name);
+                        sections.push(`## ${name}\n${tool.description}\n\nSchema:\n\`\`\`json\n${JSON.stringify(tool.input_schema, null, 2)}\n\`\`\``);
+                    }
+                    const lines = [];
+                    if (loaded.length > 0) {
+                        lines.push(`Loaded ${loaded.length} tool(s): ${loaded.join(", ")}. ` +
+                            `They are now available as first-class tools on your next turn — call directly.`);
+                        lines.push("");
+                        lines.push(sections.join("\n\n"));
+                    }
+                    if (alreadyLoaded.length > 0) {
+                        lines.push(`Already loaded: ${alreadyLoaded.join(", ")}.`);
+                    }
+                    if (errors.length > 0) {
+                        lines.push(`Errors:\n${errors.map((e) => `- ${e}`).join("\n")}`);
+                    }
+                    return {
+                        content: lines.join("\n") || "Nothing to do.",
+                        exitCode: 0,
+                        isError: loaded.length === 0 && alreadyLoaded.length === 0 && errors.length > 0,
+                    };
+                },
+            },
+        ];
+    }
+}
+// ── Factory ─────────────────────────────────────────────────────
+/** Core tool names — always sent with full schema. */
+const CORE_TOOLS = [
+    "bash", "read_file", "write_file", "edit_file",
+    "grep", "glob", "ls",
+    "list_skills",
+];
+export function createToolProtocol(mode) {
+    if (mode === "inline")
+        return new InlineToolProtocol();
+    if (mode === "deferred")
+        return new DeferredToolProtocol(CORE_TOOLS);
+    if (mode === "deferred-lookup")
+        return new DeferredLookupProtocol(CORE_TOOLS);
+    return new ApiToolProtocol();
+}

package/dist/agent/tools/bash.js

@@ -3,10 +3,10 @@ export function createBashTool(opts) {
     return {
         name: "bash",
         description: "Execute a bash command in an isolated subprocess. Output is captured and returned. " +
-            "Does not affect the user's shell state (use user_shell for cd, export, source). " +
+            "Does not affect the user's shell state. " +
+            "cwd is set to the working directory from the shell context. " +
             "Do NOT use bash for file searching — use grep/glob instead. " +
-            "Do NOT use bash for reading files — use read_file instead. " +
-            "Provide a description parameter to explain what the command does.",
+            "Do NOT use bash for reading files — use read_file instead.",
         input_schema: {
             type: "object",
             properties: {

package/dist/agent/tools/edit-file.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { computeDiff } from "../../utils/diff.js";
+import { computeEditDiff } from "../../utils/diff.js";
 /**
  * Find the closest matching region in the file content to help diagnose
  * why an exact match failed. Returns a hint string.
@@ -103,9 +103,12 @@ export function createEditFileTool(getCwd) {
                     };
                 }
                 const normalizedNew = newText.replace(/\r\n/g, "\n");
-                const newContent = replaceAll
-                    ? normalized.split(normalizedOld).join(normalizedNew)
-                    : normalized.replace(normalizedOld, normalizedNew);
+                // Use split/join for literal replacement everywhere. String.replace()
+                // treats dollar-sign patterns in the replacement as special substitution
+                // variables, which corrupts file content containing regex escape sequences.
+                const newContent = normalized.split(normalizedOld).join(normalizedNew);
+                // Note: when !replaceAll, we rely on the occurrence check above to ensure
+                // normalizedOld appears exactly once, so split/join replaces only that one.
                 // Restore original line endings — only convert if the file was
                 // predominantly CRLF (>50% of line endings), to avoid corrupting
                 // mixed-ending files.
@@ -116,8 +119,8 @@ export function createEditFileTool(getCwd) {
                     ? newContent.replace(/\n/g, "\r\n")
                     : newContent;
                 await fs.writeFile(absPath, finalContent);
-                // Compute and stream diff for display
-                const diff = computeDiff(normalized, newContent);
+                // Compute and stream diff for display (windowed — only diffs the edit region)
+                const diff = computeEditDiff(normalized, normalizedOld, normalizedNew, replaceAll);
                 if (onChunk && diff.hunks.length > 0) {
                     for (const hunk of diff.hunks) {
                         for (const line of hunk.lines) {

package/dist/agent/tools/glob.js

@@ -4,9 +4,11 @@ import { executeCommand } from "../../executor.js";
 export function createGlobTool(getCwd) {
     return {
         name: "glob",
-        description: "Find files by name pattern. Returns paths sorted by modification time (newest first). " +
+        description: "Use this when you know a FILENAME or PATH SHAPE (e.g. `**/*.ts`, `src/**/*.md`, `package.json`). " +
+            "Returns matching file paths sorted by modification time (newest first). " +
+            "This does NOT search file contents — use `grep` for that. " +
             "ALWAYS use this instead of find/ls via bash. " +
-            "Use glob to locate files, then read_file or grep to inspect contents.",
+            "Typical flow: `glob` to locate files, then `read_file` or `grep` to inspect contents.",
         input_schema: {
             type: "object",
             properties: {

package/dist/agent/tools/grep.js

@@ -2,7 +2,9 @@ import { executeCommand } from "../../executor.js";
 export function createGrepTool(getCwd) {
     return {
         name: "grep",
-        description: "Search file contents using ripgrep. ALWAYS use this instead of running grep/rg via bash. " +
+        description: "Use this when you know something INSIDE the file (text, identifier, regex). " +
+            "To find files by filename alone, use `glob` instead. " +
+            "Search file contents using ripgrep. ALWAYS use this instead of running grep/rg via bash. " +
             "Supports three output modes: " +
             "'files_with_matches' (default, returns file paths only — use this to find which files contain a pattern), " +
             "'content' (matching lines with optional context_before/context_after), and " +
@@ -13,7 +15,7 @@ export function createGrepTool(getCwd) {
             properties: {
                 pattern: {
                     type: "string",
-                    description: "Regex pattern to search for",
+                    description: "Regex pattern to search for (NOT a glob — `*.md` is invalid here; use `.*\\.md` for regex, or use the glob tool to find files by name). For filename filtering while searching content, use the `include` parameter.",
                 },
                 path: {
                     type: "string",
@@ -124,12 +126,34 @@ export function createGrepTool(getCwd) {
             });
             await done;
             if (session.exitCode === 1 && !session.output.trim()) {
+                // If the pattern looks like a filename (e.g. "SKILL.md", "package.json"),
+                // the agent probably meant to find files by name, not search inside them.
+                // Surface a redirect hint instead of a silent zero.
+                const looksLikeFilename = /^[A-Za-z0-9_.\-*/]+\.[A-Za-z0-9]{1,6}$/.test(pattern) &&
+                    !/[\\()\[\]|^$+{}]/.test(pattern);
+                const hint = looksLikeFilename
+                    ? ` Hint: "${pattern}" looks like a filename. grep searches file *contents* — to find files by name, use the \`glob\` tool instead.`
+                    : "";
                 return {
-                    content: "No matches found.",
+                    content: `No matches found.${hint}`,
                     exitCode: 0,
                     isError: false,
                 };
             }
+            // exit code >= 2 is a ripgrep error (invalid regex, unreadable path, etc).
+            // Surface it as an error so the model retries with a correct pattern
+            // rather than treating "no useful output" as a successful no-match.
+            if (session.exitCode != null && session.exitCode >= 2) {
+                const looksLikeGlob = /^[*?]|\*\./.test(pattern) && !/[\\()\[\]|^$]/.test(pattern);
+                const hint = looksLikeGlob
+                    ? " Hint: `*.md` is a glob, not a regex — use the glob tool to find files by name, or pass `include: \"*.md\"` here to filter files while searching content for a regex pattern."
+                    : "";
+                return {
+                    content: `grep failed (rg exit ${session.exitCode}): ${session.output.trim() || "no output"}${hint}`,
+                    exitCode: session.exitCode,
+                    isError: true,
+                };
+            }
             let output = session.output;
             // Cap individual line lengths to 500 chars to prevent minified/base64 flood
             if (mode === "content") {