llmist 17.1.0 → 17.3.0

package/dist/index.cjs

@@ -4660,6 +4660,9 @@ var init_create_gadget = __esm({
 });
 
 // src/gadgets/output-viewer.ts
+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) {
@@ -4684,80 +4687,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: import_zod.z.object({
       id: import_zod.z.string().describe("ID of the stored output (from the truncation message)"),
+      mode: import_zod.z.enum(["line", "character"]).default("line").describe(
+        'Browse by "line" (supports patterns) or by "character" (raw windows for dense output).'
+      ),
       patterns: import_zod.z.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: import_zod.z.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(
@@ -4773,55 +4865,77 @@ 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 import_zod, patternSchema, DEFAULT_MAX_OUTPUT_CHARS;
+var import_zod, DEFAULT_MAX_OUTPUT_CHARS, CHARACTER_HINT_WINDOW, DENSE_LINE_THRESHOLD, patternSchema;
 var init_output_viewer = __esm({
   "src/gadgets/output-viewer.ts"() {
     "use strict";
     import_zod = require("zod");
     init_create_gadget();
+    DEFAULT_MAX_OUTPUT_CHARS = 76800;
+    CHARACTER_HINT_WINDOW = 2e3;
+    DENSE_LINE_THRESHOLD = 4e3;
     patternSchema = import_zod.z.object({
       regex: import_zod.z.string().describe("Regular expression to match"),
       include: import_zod.z.boolean().default(true).describe("true = keep matching lines, false = exclude matching lines"),
       before: import_zod.z.number().int().min(0).default(0).describe("Context lines before each match (like grep -B)"),
       after: import_zod.z.number().int().min(0).default(0).describe("Context lines after each match (like grep -A)")
     });
-    DEFAULT_MAX_OUTPUT_CHARS = 76800;
   }
 });
 
@@ -4843,12 +4957,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);
@@ -4952,16 +5069,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;
         };
@@ -9950,7 +10071,7 @@ var init_openai_compatible_provider = __esm({
             inputTokens: chunk.usage.prompt_tokens,
             outputTokens: chunk.usage.completion_tokens,
             totalTokens: chunk.usage.total_tokens,
-            cachedInputTokens: 0,
+            cachedInputTokens: usageDetails?.prompt_tokens_details?.cached_tokens ?? 0,
             reasoningTokens: usageDetails?.completion_tokens_details?.reasoning_tokens
           } : void 0;
           if (finishReason || usage) {
@@ -11931,7 +12052,7 @@ var init_openrouter = __esm({
       high: "high",
       maximum: "xhigh"
     };
-    OpenRouterProvider = class extends OpenAICompatibleProvider {
+    OpenRouterProvider = class _OpenRouterProvider extends OpenAICompatibleProvider {
       providerId = "openrouter";
       providerAlias = "or";
       constructor(client, config = {}) {
@@ -11941,8 +12062,10 @@ var init_openrouter = __esm({
         return OPENROUTER_MODELS;
       }
       /**
-       * Override buildApiRequest to inject reasoning parameters.
-       * OpenRouter normalizes reasoning into the standard OpenAI format.
+       * Override buildApiRequest to inject reasoning parameters and cache_control breakpoints.
+       * OpenRouter normalizes reasoning into the standard OpenAI format,
+       * and supports cache_control on message content blocks for both
+       * Anthropic Claude and Google Gemini models.
        */
       buildApiRequest(options, descriptor, spec, messages) {
         const request = super.buildApiRequest(options, descriptor, spec, messages);
@@ -11952,8 +12075,49 @@ var init_openrouter = __esm({
             effort: OPENROUTER_EFFORT_MAP[options.reasoning.effort ?? "medium"]
           };
         }
+        const cachingEnabled = options.caching?.enabled !== false;
+        if (cachingEnabled) {
+          this.injectCacheBreakpoints(request);
+        }
         return request;
       }
+      /** Minimal shape for messages in the already-built OpenAI-compatible request. */
+      static CACHE_CONTROL = { type: "ephemeral" };
+      /**
+       * Add cache_control breakpoints to the last system message and last user message.
+       * This enables OpenRouter's prompt caching for supported providers (Anthropic, Gemini).
+       *
+       * Operates on the already-built request object. We cast through `unknown` because
+       * OpenAI's `ChatCompletionMessageParam` union is too narrow to assign content arrays
+       * with the non-standard `cache_control` property.
+       */
+      injectCacheBreakpoints(request) {
+        const msgs = request.messages;
+        let lastSystemIdx = -1;
+        let lastUserIdx = -1;
+        for (let i = 0; i < msgs.length; i++) {
+          if (msgs[i].role === "system") lastSystemIdx = i;
+          if (msgs[i].role === "user") lastUserIdx = i;
+        }
+        if (lastSystemIdx >= 0) {
+          msgs[lastSystemIdx].content = this.withCacheControl(msgs[lastSystemIdx].content);
+        }
+        if (lastUserIdx >= 0) {
+          msgs[lastUserIdx].content = this.withCacheControl(msgs[lastUserIdx].content);
+        }
+      }
+      /**
+       * Return a new content array with cache_control on the last block.
+       * String content is promoted to a single-element text block array.
+       */
+      withCacheControl(content) {
+        if (typeof content === "string") {
+          return [{ type: "text", text: content, cache_control: _OpenRouterProvider.CACHE_CONTROL }];
+        }
+        return content.map(
+          (block, i) => i === content.length - 1 ? { ...block, cache_control: _OpenRouterProvider.CACHE_CONTROL } : block
+        );
+      }
       /**
        * Get custom headers for OpenRouter analytics.
        */