llmist 17.2.1 → 17.3.0

package/dist/index.d.cts

@@ -5821,10 +5821,14 @@ interface StoredOutput {
     gadgetName: string;
     /** Full output content */
     content: string;
+    /** Total character count of the stored content */
+    charCount: number;
     /** Size in bytes */
     byteSize: number;
     /** Number of lines */
     lineCount: number;
+    /** Length of the longest line in characters */
+    maxLineLength: number;
     /** When the output was stored */
     timestamp: Date;
 }
@@ -8564,19 +8568,9 @@ declare function resultWithFile(result: string, fileData: Buffer | Uint8Array, m
 /**
  * Create a GadgetOutputViewer gadget instance bound to a specific output store.
  *
- * This is a factory function because the gadget needs access to the output store,
- * which is created per-agent-run.
- *
  * @param store - The GadgetOutputStore to read outputs from
  * @param maxOutputChars - Maximum characters to return (default: 76,800 = ~19k tokens)
  * @returns A GadgetOutputViewer gadget instance
- *
- * @example
- * ```typescript
- * const store = new GadgetOutputStore();
- * const viewer = createGadgetOutputViewer(store, 76_800);
- * registry.register("GadgetOutputViewer", viewer);
- * ```
  */
 declare function createGadgetOutputViewer(store: GadgetOutputStore, maxOutputChars?: number): AbstractGadget;
 

package/dist/index.d.ts

@@ -5821,10 +5821,14 @@ interface StoredOutput {
     gadgetName: string;
     /** Full output content */
     content: string;
+    /** Total character count of the stored content */
+    charCount: number;
     /** Size in bytes */
     byteSize: number;
     /** Number of lines */
     lineCount: number;
+    /** Length of the longest line in characters */
+    maxLineLength: number;
     /** When the output was stored */
     timestamp: Date;
 }
@@ -8564,19 +8568,9 @@ declare function resultWithFile(result: string, fileData: Buffer | Uint8Array, m
 /**
  * Create a GadgetOutputViewer gadget instance bound to a specific output store.
  *
- * This is a factory function because the gadget needs access to the output store,
- * which is created per-agent-run.
- *
  * @param store - The GadgetOutputStore to read outputs from
  * @param maxOutputChars - Maximum characters to return (default: 76,800 = ~19k tokens)
  * @returns A GadgetOutputViewer gadget instance
- *
- * @example
- * ```typescript
- * const store = new GadgetOutputStore();
- * const viewer = createGadgetOutputViewer(store, 76_800);
- * registry.register("GadgetOutputViewer", viewer);
- * ```
  */
 declare function createGadgetOutputViewer(store: GadgetOutputStore, maxOutputChars?: number): AbstractGadget;
 

package/dist/index.js

@@ -4654,6 +4654,9 @@ var init_create_gadget = __esm({
 
 // src/gadgets/output-viewer.ts
 import { z as z3 } from "zod";
+function pluralize(count, singular, plural = `${singular}s`) {
+  return count === 1 ? singular : plural;
+}
 function applyPattern(lines, pattern) {
   const regex = new RegExp(pattern.regex);
   if (!pattern.include) {
@@ -4678,80 +4681,169 @@ function applyPatterns(lines, patterns) {
   }
   return result;
 }
-function applyLineLimit(lines, limit) {
+function parseLimitWindow(limit) {
   const trimmed = limit.trim();
   if (trimmed.endsWith("-") && !trimmed.startsWith("-")) {
     const n = parseInt(trimmed.slice(0, -1), 10);
-    if (!isNaN(n) && n > 0) {
-      return lines.slice(0, n);
+    if (!Number.isNaN(n) && n > 0) {
+      return { kind: "first", count: n };
     }
   }
   if (trimmed.startsWith("-") && !trimmed.includes("-", 1)) {
     const n = parseInt(trimmed, 10);
-    if (!isNaN(n) && n < 0) {
-      return lines.slice(n);
+    if (!Number.isNaN(n) && n < 0) {
+      return { kind: "last", count: Math.abs(n) };
     }
   }
   const rangeMatch = trimmed.match(/^(\d+)-(\d+)$/);
   if (rangeMatch) {
     const start = parseInt(rangeMatch[1], 10);
     const end = parseInt(rangeMatch[2], 10);
-    if (!isNaN(start) && !isNaN(end) && start > 0 && end >= start) {
-      return lines.slice(start - 1, end);
+    if (!Number.isNaN(start) && !Number.isNaN(end) && start > 0 && end >= start) {
+      return { kind: "range", start, end };
     }
   }
-  return lines;
+  return null;
+}
+function applyLineLimit(lines, limit) {
+  const window = parseLimitWindow(limit);
+  if (!window) return lines;
+  switch (window.kind) {
+    case "first":
+      return lines.slice(0, window.count);
+    case "last":
+      return lines.slice(-window.count);
+    case "range":
+      return lines.slice(window.start - 1, window.end);
+  }
+}
+function applyCharacterLimit(content, limit, maxOutputChars) {
+  const total = content.length;
+  if (total === 0) {
+    return { text: "", start: 0, end: 0, total: 0, truncatedBySize: false, hasMoreAfter: false };
+  }
+  let startIndex = 0;
+  let endExclusive = total;
+  const window = limit ? parseLimitWindow(limit) : null;
+  if (window) {
+    switch (window.kind) {
+      case "first":
+        endExclusive = Math.min(window.count, total);
+        break;
+      case "last":
+        startIndex = Math.max(0, total - window.count);
+        break;
+      case "range":
+        startIndex = Math.min(window.start - 1, total);
+        endExclusive = Math.min(window.end, total);
+        break;
+    }
+  }
+  let text3 = content.slice(startIndex, endExclusive);
+  let truncatedBySize = false;
+  if (text3.length > maxOutputChars) {
+    text3 = window?.kind === "last" ? text3.slice(-maxOutputChars) : text3.slice(0, maxOutputChars);
+    if (window?.kind === "last") {
+      startIndex = endExclusive - text3.length;
+    }
+    truncatedBySize = true;
+  }
+  return {
+    text: text3,
+    start: text3.length === 0 ? 0 : startIndex + 1,
+    end: text3.length === 0 ? 0 : startIndex + text3.length,
+    total,
+    truncatedBySize,
+    hasMoreAfter: startIndex + text3.length < total
+  };
+}
+function buildCharacterRangeHint(start, total) {
+  if (total <= 0 || start > total) return null;
+  const end = Math.min(total, start + CHARACTER_HINT_WINDOW - 1);
+  return `${start}-${end}`;
+}
+function buildCharacterModeSuggestion(stored, opts = {}) {
+  const hint = buildCharacterRangeHint(opts.start ?? 1, stored.charCount);
+  const action = opts.removePatterns ? "Remove patterns and then try" : "Try";
+  const lineLabel = pluralize(stored.lineCount, "line");
+  return `This output is dense (${stored.lineCount.toLocaleString()} ${lineLabel}; longest line ${stored.maxLineLength.toLocaleString()} chars). ${action} mode: "character"` + (hint ? `, limit: "${hint}"` : "") + ".";
+}
+function shouldSuggestCharacterMode(stored, maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS) {
+  return stored.lineCount <= 3 && (stored.maxLineLength > maxOutputChars || stored.maxLineLength >= DENSE_LINE_THRESHOLD);
 }
 function createGadgetOutputViewer(store, maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS) {
   return createGadget({
     name: "GadgetOutputViewer",
-    description: "View stored output from gadgets that returned too much data. Use patterns to filter lines (like grep) and limit to control output size. Patterns are applied first in order, then the limit is applied to the result.",
+    description: 'View stored output from gadgets that returned too much data. Use mode "line" for grep-like filtering and mode "character" for raw chunked browsing when the output is dense or effectively single-line. Patterns work only in line mode.',
     schema: z3.object({
       id: z3.string().describe("ID of the stored output (from the truncation message)"),
+      mode: z3.enum(["line", "character"]).default("line").describe(
+        'Browse by "line" (supports patterns) or by "character" (raw windows for dense output).'
+      ),
       patterns: z3.array(patternSchema).optional().describe(
-        "Filter patterns applied in order (like piping through grep). Each pattern can include or exclude lines with optional before/after context."
+        'Line-mode filter patterns applied in order (like piping through grep). Not supported in mode "character".'
       ),
       limit: z3.string().optional().describe(
-        "Line range to return after filtering. Formats: '100-' (first 100), '-25' (last 25), '50-100' (lines 50-100)"
+        `Pagination window. In mode "line" it is a line range; in mode "character" it is a character range. Formats: "100-" (first 100), "-25" (last 25), "50-100" (inclusive range).`
       )
     }),
     examples: [
       {
         comment: "View first 50 lines of stored output",
-        params: { id: "Search_abc12345", limit: "50-" }
+        params: { id: "Search_abc12345", mode: "line", limit: "50-" }
       },
       {
         comment: "Filter for error lines with context",
         params: {
           id: "Search_abc12345",
+          mode: "line",
           patterns: [{ regex: "error|Error|ERROR", include: true, before: 2, after: 5 }]
         }
       },
       {
-        comment: "Exclude blank lines, then show first 100",
+        comment: "Exclude blank lines, then show first 100 lines",
         params: {
           id: "Search_abc12345",
+          mode: "line",
           patterns: [{ regex: "^\\s*$", include: false, before: 0, after: 0 }],
           limit: "100-"
         }
       },
       {
-        comment: "Chain filters: find TODOs, exclude tests, limit to 50 lines",
+        comment: "Browse the raw output by character window when line mode is too dense",
         params: {
           id: "Search_abc12345",
-          patterns: [
-            { regex: "TODO", include: true, before: 1, after: 1 },
-            { regex: "test|spec", include: false, before: 0, after: 0 }
-          ],
-          limit: "50-"
+          mode: "character",
+          limit: "1-2000"
         }
       }
     ],
-    execute: ({ id, patterns, limit }) => {
+    execute: ({ id, mode, patterns, limit }) => {
       const stored = store.get(id);
       if (!stored) {
         return `Error: No stored output with id "${id}". Available IDs: ${store.getIds().join(", ") || "(none)"}`;
       }
+      const suggestCharacterMode = shouldSuggestCharacterMode(stored, maxOutputChars);
+      if (mode === "character") {
+        if (patterns && patterns.length > 0) {
+          return 'Error: patterns are only supported in mode "line". Remove patterns or switch back to mode: "line".';
+        }
+        const window = applyCharacterLimit(stored.content, limit, maxOutputChars);
+        if (window.total === 0) {
+          return "[Mode: character | Output is empty]";
+        }
+        const header2 = [
+          `[Mode: character | Showing chars ${window.start.toLocaleString()}-${window.end.toLocaleString()} of ${window.total.toLocaleString()}${window.truncatedBySize ? " (truncated due to viewer size limit)" : ""}]`
+        ];
+        if (window.hasMoreAfter) {
+          const nextRange = buildCharacterRangeHint(window.end + 1, window.total);
+          if (nextRange) {
+            header2.push(`[Next chunk: mode: "character", limit: "${nextRange}"]`);
+          }
+        }
+        return `${header2.join("\n")}
+${window.text}`;
+      }
       let lines = stored.content.split("\n");
       if (patterns && patterns.length > 0) {
         lines = applyPatterns(
@@ -4767,54 +4859,76 @@ function createGadgetOutputViewer(store, maxOutputChars = DEFAULT_MAX_OUTPUT_CHA
       if (limit) {
         lines = applyLineLimit(lines, limit);
       }
-      let output = lines.join("\n");
       const totalLines = stored.lineCount;
+      const totalLineLabel = pluralize(totalLines, "line");
       const returnedLines = lines.length;
       if (returnedLines === 0) {
-        return `No lines matched the filters. Original output had ${totalLines} lines.`;
+        const base = `No lines matched the filters. Original output had ${totalLines.toLocaleString()} lines.`;
+        if (!suggestCharacterMode) return base;
+        return `${base} ${buildCharacterModeSuggestion(stored, {
+          removePatterns: Boolean(patterns && patterns.length > 0)
+        })}`;
       }
+      let output = lines.join("\n");
       let truncatedBySize = false;
       let linesIncluded = returnedLines;
+      let clippedFirstLine = false;
       if (output.length > maxOutputChars) {
         truncatedBySize = true;
         let truncatedOutput = "";
         linesIncluded = 0;
         for (const line of lines) {
-          if (truncatedOutput.length + line.length + 1 > maxOutputChars) break;
-          truncatedOutput += line + "\n";
+          const addition = linesIncluded === 0 ? line : `
+${line}`;
+          if (truncatedOutput.length + addition.length > maxOutputChars) break;
+          truncatedOutput += addition;
           linesIncluded++;
         }
+        if (linesIncluded === 0) {
+          clippedFirstLine = true;
+          linesIncluded = 1;
+          truncatedOutput = lines[0].slice(0, maxOutputChars);
+        }
         output = truncatedOutput;
       }
       let header;
-      if (truncatedBySize) {
+      if (clippedFirstLine) {
+        header = `[Mode: line | Showing 1 partial line of ${totalLines.toLocaleString()} ${totalLineLabel} (the selected line exceeds the viewer size limit)]
+`;
+      } else if (truncatedBySize) {
         const remainingLines = returnedLines - linesIncluded;
-        header = `[Showing ${linesIncluded} of ${totalLines} lines (truncated due to size limit)]
-[... ${remainingLines.toLocaleString()} more lines. Use limit parameter to paginate, e.g., limit: "${linesIncluded + 1}-${linesIncluded + 200}"]
+        header = `[Mode: line | Showing ${linesIncluded.toLocaleString()} of ${totalLines.toLocaleString()} ${totalLineLabel} (truncated due to size limit)]
+[... ${remainingLines.toLocaleString()} more ${pluralize(remainingLines, "line")}. Use limit parameter to paginate, e.g., limit: "${linesIncluded + 1}-${linesIncluded + 200}"]
 `;
       } else if (returnedLines < totalLines) {
-        header = `[Showing ${returnedLines} of ${totalLines} lines]
+        header = `[Mode: line | Showing ${returnedLines.toLocaleString()} of ${totalLines.toLocaleString()} ${totalLineLabel}]
 `;
       } else {
-        header = `[Showing all ${totalLines} lines]
+        header = `[Mode: line | Showing all ${totalLines.toLocaleString()} ${totalLineLabel}]
 `;
       }
-      return header + output;
+      const footer = suggestCharacterMode || clippedFirstLine ? `
+[Tip: ${buildCharacterModeSuggestion(stored, {
+        removePatterns: Boolean(patterns && patterns.length > 0)
+      })}]` : "";
+      return header + output + footer;
     }
   });
 }
-var patternSchema, DEFAULT_MAX_OUTPUT_CHARS;
+var DEFAULT_MAX_OUTPUT_CHARS, CHARACTER_HINT_WINDOW, DENSE_LINE_THRESHOLD, patternSchema;
 var init_output_viewer = __esm({
   "src/gadgets/output-viewer.ts"() {
     "use strict";
     init_create_gadget();
+    DEFAULT_MAX_OUTPUT_CHARS = 76800;
+    CHARACTER_HINT_WINDOW = 2e3;
+    DENSE_LINE_THRESHOLD = 4e3;
     patternSchema = z3.object({
       regex: z3.string().describe("Regular expression to match"),
       include: z3.boolean().default(true).describe("true = keep matching lines, false = exclude matching lines"),
       before: z3.number().int().min(0).default(0).describe("Context lines before each match (like grep -B)"),
       after: z3.number().int().min(0).default(0).describe("Context lines after each match (like grep -A)")
     });
-    DEFAULT_MAX_OUTPUT_CHARS = 76800;
   }
 });
 
@@ -4836,12 +4950,15 @@ var init_gadget_output_store = __esm({
       store(gadgetName, content) {
         const id = this.generateId(gadgetName);
         const encoder = new TextEncoder();
+        const lines = content.split("\n");
         const stored = {
           id,
           gadgetName,
           content,
+          charCount: content.length,
           byteSize: encoder.encode(content).length,
-          lineCount: content.split("\n").length,
+          lineCount: lines.length,
+          maxLineLength: lines.reduce((max, line) => Math.max(max, line.length), 0),
           timestamp: /* @__PURE__ */ new Date()
         };
         this.outputs.set(id, stored);
@@ -4945,16 +5062,20 @@ var init_output_limit_manager = __esm({
           }
           if (result.length > this.charLimit) {
             const id = this.outputStore.store(ctx.gadgetName, result);
-            const lines = result.split("\n").length;
-            const bytes = new TextEncoder().encode(result).length;
+            const stored = this.outputStore.get(id);
+            const lines = stored?.lineCount ?? result.split("\n").length;
+            const bytes = stored?.byteSize ?? new TextEncoder().encode(result).length;
+            const denseSuggestion = stored && shouldSuggestCharacterMode(stored, this.charLimit) ? ` ${buildCharacterModeSuggestion(stored)}` : "";
             this.logger.info("Gadget output exceeded limit, stored for browsing", {
               gadgetName: ctx.gadgetName,
               outputId: id,
               bytes,
               lines,
+              charCount: stored?.charCount,
+              maxLineLength: stored?.maxLineLength,
               charLimit: this.charLimit
             });
-            return `[Gadget "${ctx.gadgetName}" returned too much data: ${bytes.toLocaleString()} bytes, ${lines.toLocaleString()} lines. Use GadgetOutputViewer with id "${id}" to read it]`;
+            return `[Gadget "${ctx.gadgetName}" returned too much data: ${bytes.toLocaleString()} bytes, ${lines.toLocaleString()} lines. Use GadgetOutputViewer with id "${id}" to read it.]` + denseSuggestion;
           }
           return result;
         };