llm_meta_widget 0.12.1 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 845c38baf1aca6cc874a77c9f324895c6001664dffe4d891d8b31ed2057a3b2b
-  data.tar.gz: 825acda8a84c599e09e8d11cad9fe738092aa807b41911a99889e76dab15c800
+  metadata.gz: 9d3172a4471dd7326d3455cbb4d39ed5f19092df52e81828b98d71a0c541da57
+  data.tar.gz: 1ec235057d668445bcb40cdb6b584cc73c1c579ee54c2cf36b7bcef699efb5b9
 SHA512:
-  metadata.gz: 0244dc664c60f88e1cf29e9cb52ebc9e33bf61e8ab2ab180a8e0873d587bf1cf96d8865eeb9d97b0fe325cec00c43e6e154cef74c511f7f16894a2112d17ad23
-  data.tar.gz: 5584f49e2c7e848ef93fdb5bf6cb1270fa3154f77beee255eb64e221aab20ce8e4828b4b8381c5268e1503b1b0967d4fab81811be718f23f247951ccdf1c142a
+  metadata.gz: 1dcda012841f3a4c1f253c837d1149292f0c19cdc6a5396cb7ab7064bfb0ac0dbae5414bc0e33529fb925a4d5b15de28a78cda13bba26bf4856fca84f13a94e2
+  data.tar.gz: 338955619e9f6712e6889bbe62a295de75b7cf9cb6571d7cd9aab0ac227b52caf5d6c891b14ef136bcc115e6da0f721f441b4a9a7bd3be96248d55cde441870e

data/CHANGELOG.md

@@ -3,6 +3,59 @@
 This file starts at 0.8.0, the first release with a breaking change worth
 calling out. Earlier releases are in the git history (`git log --oneline v0.7.6`).
 
+## 0.12.2
+
+### Changed: one oversized tool result is shortened, not paid for by the others
+
+A single tool result may now use at most 40% of the model's context window. A
+result above that is cut to the cap, with a note in the result itself telling
+the model how much was shown and to call the tool again with a narrower query.
+
+This replaces giving up older results as the first response to a turn that will
+not fit. Dropping the oldest results is a sound rule when results are of
+similar size, and a poor one otherwise: on a real turn (2026-10-17) it gave up
+two results of 80 tokens each — 160 tokens against a shortfall of about 2,600 —
+and left untouched the one result that was causing the problem, at 120,667
+tokens, or 94% of the window. The two results it discarded were ones the model
+had asked for.
+
+Measured over 179 real tool results: the median is 2.1% of the window, so the
+cap touches 4.5% of results. All six over-budget requests in that sample were
+caused by one oversized result, and the cap clears every one of them. On the
+turn above it frees about 69,000 tokens and nothing has to be given up at all.
+
+Giving up older results remains, for a conversation that is too long in
+aggregate rather than because of one result.
+
+The panel reports both, with the numbers: what was shortened or given up, how
+many tokens the turn needed, and how many the model holds.
+
+### Fixed: scrolling the panel after a turn with thinking blocks (Chrome)
+
+After a turn that showed thinking blocks, the panel could not be scrolled. The
+scrollbar moved a few tens of pixels and stopped, by wheel, trackpad and
+keyboard alike, while `scrollTop` set from script still worked and held. This
+was reported from two different deployments and took several wrong diagnoses
+from us before the mechanism was found.
+
+A thinking block is a `<details>` holding its own scroller. Closing one with
+`open = false`, at a moment when that block is the only reason the message list
+overflows, leaves Chrome with a stale wheel range — the list's overflow from
+that instant, often only tens of pixels. `scrollTop` and `scrollHeight` remain
+correct, which is why nothing in the page looked wrong. Chrome 154 reproduces
+it with no widget code involved at all; Firefox 158 does not, and it has been
+reported upstream.
+
+The widget now takes the scroller off the inner box before closing it, and
+closes on the second animation frame, because one frame is not enough for
+Chrome to pick up the new overflow. Measured on a real deployment: 6 of 6 turns
+healthy after the change, against 3 of 4 faulting before, with the triggering
+condition confirmed present 2 to 4 times in every passing run.
+
+One consequence: a finished thinking block that a reader reopens is shown at
+full height rather than as a 10em scrolling box. Putting the scroller back when
+it reopens would let a manual close trigger the same Chrome state again.
+
 ## 0.12.1
 
 ### Fixed: a tool result is counted as JSON, not as prose
@@ -29,8 +82,8 @@ heard that the reader had moved — and the pin put them back at the end, so the
 decision never flipped. The question is now asked synchronously, immediately
 before anything is added, which has no such window.
 
-A separate report of the panel jumping to the TOP after a turn ends is not
-explained by this and remains open.
+A separate report of the panel jumping to the TOP after a turn ends had a
+different cause, fixed in 0.12.2 below.
 
 ## 0.12.0
 

data/README.md

@@ -61,7 +61,7 @@ Option 3 if it does not.
 
 ```ruby
 # Gemfile
-gem "llm_meta_widget", "~> 0.12.1"
+gem "llm_meta_widget", "~> 0.12.2"
 ```
 
 ```bash

data/app/assets/javascripts/llm_meta_widget/element.js

@@ -169,6 +169,12 @@ function boot(cfg) {
   	// and we stop following; come back to it and we resume.
   	var SCROLL_PIN_SLACK = 40;   // px from the end still counts as "at the end"
 
+  	// Rounded to the nearest thousand and grouped, so the numbers read as a
+  	// scale rather than as a precise count the estimate cannot support.
+  	function thousands(n) {
+  		return (Math.round(n / 1000) * 1000).toLocaleString("en-US");
+  	}
+
   	function atBottom() {
   		return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
   	}
@@ -1127,15 +1133,45 @@ function boot(cfg) {
   		return body;
   	}
 
+  	// Collapsing a thinking block is what broke scrolling in Chrome.
+  	//
+  	// A thinking block is a <details> holding its own scroller (max-height +
+  	// overflow-y on .message-thinking-content). Closing it with `open = false`
+  	// at a moment when that block is the only reason .lmw-messages overflows
+  	// makes the list briefly non-scrollable. When later content makes it
+  	// scrollable again, Chrome keeps the WHEEL range from that moment — tens of
+  	// pixels — while scrollTop and scrollHeight stay correct. So the reader can
+  	// scroll a few pixels and no further, by any input method, while
+  	// `scrollTop = 600` set from script still works. Chrome 154 reproduces it
+  	// with no widget code at all; Firefox 158 never does (reported 2026-10-17).
+  	//
+  	// Taking the scroller off the inner box BEFORE the close avoids the state.
+  	// Two frames, because one is not enough for Chrome to pick up the new
+  	// overflow before the close lands.
+  	//
+  	// The box stays a non-scroller afterwards, so a reader who reopens a
+  	// finished block sees it at full height instead of a 10em window. Putting
+  	// the scroller back on reopen would let a manual close trigger the bug
+  	// again, which is a worse trade.
   	function collapseThinkingBlock() {
-  		if (currentThinkingBlock) {
-  			currentThinkingBlock.classList.remove("thinking-active");
-  			currentThinkingBlock.open = false;
-  			var summary = currentThinkingBlock.querySelector("summary");
-  			if (summary) summary.textContent = "🤔 thinking (finished)";
-  		}
+  		var block = currentThinkingBlock;
   		currentThinkingBlock = null;
   		currentThinkingBody  = null;
+  		if (!block) return;
+
+  		block.classList.remove("thinking-active");
+  		var summary = block.querySelector("summary");
+  		if (summary) summary.textContent = "🤔 thinking (finished)";
+
+  		var body = block.querySelector(".message-thinking-content");
+  		if (body) {
+  			body.style.overflow  = "visible";
+  			body.style.maxHeight = "none";
+  		}
+  		if (typeof requestAnimationFrame !== "function") { block.open = false; return; }
+  		requestAnimationFrame(function() {
+  			requestAnimationFrame(function() { block.open = false; });
+  		});
   	}
 
   	// Every declaration channel the widget hands the model carries a
@@ -1317,12 +1353,31 @@ function boot(cfg) {
   				contextWindow: modelWindow,
   				provider:      LLM_PROVIDER === "ollama" ? "ollama" : "hub",
   				signal:        currentAbort.signal,
-  				onContextEvicted: function(dropped) {
-  					// Said out loud: a context that quietly thins out makes a later answer
-  					// look inexplicably worse, with nothing on screen to explain it.
-  					var last = dropped[dropped.length - 1];
-  					var name = (last && last.name) ? last.name : "tool";
-  					appendTurn("system", "Dropped an earlier " + name + " result to make room in the model's context. Ask again if you need it.");
+  				onContextTruncated: function(list) {
+  					// A shortened result is not a failure, but the reader has to know the
+  					// model answered from part of it — and the numbers say whether a narrower
+  					// question would help.
+  					var cut = list[list.length - 1] || {};
+  					appendTurn("system", "Shortened an oversized " + (cut.name || "tool") + " result to fit the context: " +
+  						thousands(cut.fromTokens || 0) + " tokens, where one result may use at most " +
+  						thousands(cut.toTokens || 0) + ". Ask again with a narrower question for the complete result.");
+  				},
+  				onContextEvicted: function(info) {
+  					// Said out loud, with the numbers. A context that quietly thins out makes
+  					// a later answer look inexplicably worse, and "an old result was dropped"
+  					// alone does not tell a reader whether to retry, shorten the question, or
+  					// pick a model with more room.
+  					var dropped = info.dropped || [];
+  					var names = dropped.map(function(d) { return d.name || "a tool"; });
+  					var what = names.length === 1
+  						? "the earliest tool result (" + names[0] + ")"
+  						: "the " + names.length + " earliest tool results (" + names.join(", ") + ")";
+  					var sizes = (info.needed && info.window)
+  						? " About " + thousands(info.needed) + " tokens were needed and " +
+  						  thousands(info.window) + " fit in " + MODEL + "'s context."
+  						: "";
+  					appendTurn("system", "Dropped " + what + " to make room." + sizes +
+  						" Ask again, or narrow the question, for an answer based on complete tool results.");
   				},
   				onToolCall: function(toolCall) {
   					announceToolCall(toolCall);

data/app/assets/javascripts/llm_meta_widget/llm-meta-widget.js

@@ -178,6 +178,8 @@ async function runChatLoop(opts) {
     // Called when a tool result is dropped to make room, so the panel can say
     // so rather than the context quietly thinning.
     onContextEvicted,
+    // Called when one oversized result is shortened, so the panel can say so.
+    onContextTruncated,
     // "hub" (default) talks to llm_meta_server; "ollama" talks straight to an
     // Ollama, with no server component of ours in between. The loop is the
     // same either way — only the call is swapped.
@@ -211,6 +213,7 @@ async function runChatLoop(opts) {
   const mergedLocalTools = Object.values(inlineByName);
   const rounds = [];
   const evicted = [];
+  const truncatedResults = [];
   const toolsTokens = estimateToolsTokens([].concat(
     singleOpts.localTools || [],
     remoteTools || [],
@@ -246,6 +249,15 @@ async function runChatLoop(opts) {
   for (let round = 0; round < maxRounds; round++) {
     if (signal?.aborted) throw new DOMException("aborted", "AbortError");
     onRoundStart?.(round);
+    const capped = truncateOversizedToolResults({
+      messages,
+      window: contextWindow,
+      truncated: truncatedResults
+    });
+    if (capped.messages !== messages) {
+      messages = capped.messages;
+      onContextTruncated?.(truncatedResults.slice());
+    }
     const room = evictOldToolResults({
       messages,
       window: contextWindow,
@@ -255,7 +267,7 @@ async function runChatLoop(opts) {
     });
     if (room.messages !== messages) {
       messages = room.messages;
-      onContextEvicted?.(evicted.slice());
+      onContextEvicted?.({ dropped: evicted.slice(), needed: room.needed, window: room.window });
     }
     const call = provider === "ollama" ? ollamaChatCall : singleLlmCall;
     const turnResult = await call({
@@ -622,10 +634,34 @@ function estimateToolsTokens(tools) {
   })).join("");
   return estimateTextTokens(text);
 }
+var MAX_TOOL_RESULT_SHARE = 0.4;
+function truncateOversizedToolResults({
+  messages,
+  window: window2,
+  share = MAX_TOOL_RESULT_SHARE,
+  truncated = []
+} = {}) {
+  if (!window2 || !Number.isFinite(window2)) return { messages, truncated };
+  const cap = Math.floor(window2 * share);
+  let out = null;
+  (messages || []).forEach((m, i) => {
+    if (m?.role !== "tool" || typeof m.content !== "string") return;
+    const tokens = estimateTextTokens(m.content);
+    if (tokens <= cap) return;
+    const keep = Math.max(1, Math.floor(m.content.length * cap / tokens));
+    out = out || messages.slice();
+    truncated.push({ name: m.name, fromTokens: tokens, toTokens: cap });
+    out[i] = Object.assign({}, m, {
+      content: m.content.slice(0, keep) + "\n\n[truncated: " + keep + " of " + m.content.length + " characters shown. One tool result may use at most " + Math.round(share * 100) + "% of the context window. Call the tool again with a narrower query to see more.]"
+    });
+  });
+  return { messages: out || messages, truncated };
+}
 function evictOldToolResults({ messages, window: window2, reserve = 0, dropped = [] }) {
   if (!window2 || !Number.isFinite(window2)) return { messages, dropped };
   const budget = window2 - reserve;
-  if (estimateTokens(messages) <= budget) return { messages, dropped };
+  const needed = estimateTokens(messages) + reserve;
+  if (estimateTokens(messages) <= budget) return { messages, dropped, needed, window: window2 };
   const out = messages.slice();
   for (let i = 0; i < out.length; i++) {
     if (estimateTokens(out) <= budget) break;
@@ -637,7 +673,7 @@ function evictOldToolResults({ messages, window: window2, reserve = 0, dropped =
       content: "[dropped to make room in the context window. Call the tool again if you still need it, with a narrower query.]"
     });
   }
-  return { messages: out, dropped };
+  return { messages: out, dropped, needed, window: window2 };
 }
 function modelWindowFrom(payload, modelId) {
   for (const family of payload && payload.llms || []) {
@@ -3952,6 +3988,9 @@ function boot(cfg) {
   var toggleBtn = document.getElementById("llm-meta-widget-toggle");
   var historyEl = root.querySelector(".lmw-messages");
   var SCROLL_PIN_SLACK = 40;
+  function thousands(n) {
+    return (Math.round(n / 1e3) * 1e3).toLocaleString("en-US");
+  }
   function atBottom() {
     return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
   }
@@ -4643,14 +4682,27 @@ function boot(cfg) {
     return body;
   }
   function collapseThinkingBlock() {
-    if (currentThinkingBlock) {
-      currentThinkingBlock.classList.remove("thinking-active");
-      currentThinkingBlock.open = false;
-      var summary = currentThinkingBlock.querySelector("summary");
-      if (summary) summary.textContent = "\u{1F914} thinking (finished)";
-    }
+    var block2 = currentThinkingBlock;
     currentThinkingBlock = null;
     currentThinkingBody = null;
+    if (!block2) return;
+    block2.classList.remove("thinking-active");
+    var summary = block2.querySelector("summary");
+    if (summary) summary.textContent = "\u{1F914} thinking (finished)";
+    var body = block2.querySelector(".message-thinking-content");
+    if (body) {
+      body.style.overflow = "visible";
+      body.style.maxHeight = "none";
+    }
+    if (typeof requestAnimationFrame !== "function") {
+      block2.open = false;
+      return;
+    }
+    requestAnimationFrame(function() {
+      requestAnimationFrame(function() {
+        block2.open = false;
+      });
+    });
   }
   function stateReaders() {
     var declared = window[STATE_GLOBAL] || {};
@@ -4793,10 +4845,18 @@ function boot(cfg) {
         contextWindow: modelWindow,
         provider: LLM_PROVIDER === "ollama" ? "ollama" : "hub",
         signal: currentAbort.signal,
-        onContextEvicted: function(dropped) {
-          var last = dropped[dropped.length - 1];
-          var name = last && last.name ? last.name : "tool";
-          appendTurn("system", "Dropped an earlier " + name + " result to make room in the model's context. Ask again if you need it.");
+        onContextTruncated: function(list2) {
+          var cut = list2[list2.length - 1] || {};
+          appendTurn("system", "Shortened an oversized " + (cut.name || "tool") + " result to fit the context: " + thousands(cut.fromTokens || 0) + " tokens, where one result may use at most " + thousands(cut.toTokens || 0) + ". Ask again with a narrower question for the complete result.");
+        },
+        onContextEvicted: function(info) {
+          var dropped = info.dropped || [];
+          var names = dropped.map(function(d) {
+            return d.name || "a tool";
+          });
+          var what = names.length === 1 ? "the earliest tool result (" + names[0] + ")" : "the " + names.length + " earliest tool results (" + names.join(", ") + ")";
+          var sizes = info.needed && info.window ? " About " + thousands(info.needed) + " tokens were needed and " + thousands(info.window) + " fit in " + MODEL + "'s context." : "";
+          appendTurn("system", "Dropped " + what + " to make room." + sizes + " Ask again, or narrow the question, for an answer based on complete tool results.");
         },
         onToolCall: function(toolCall) {
           announceToolCall(toolCall);

data/app/assets/javascripts/llm_meta_widget/orchestrator.js

@@ -335,6 +335,8 @@ export async function runChatLoop(opts) {
     // Called when a tool result is dropped to make room, so the panel can say
     // so rather than the context quietly thinning.
     onContextEvicted,
+    // Called when one oversized result is shortened, so the panel can say so.
+    onContextTruncated,
     // "hub" (default) talks to llm_meta_server; "ollama" talks straight to an
     // Ollama, with no server component of ours in between. The loop is the
     // same either way — only the call is swapped.
@@ -377,6 +379,7 @@ export async function runChatLoop(opts) {
 
   const rounds = []
   const evicted = []
+  const truncatedResults = []
   // Fixed for the turn: the declared tool set does not change between rounds.
   const toolsTokens = estimateToolsTokens([].concat(
   	singleOpts.localTools || [], remoteTools || [], hostWideTools || []))
@@ -422,6 +425,16 @@ export async function runChatLoop(opts) {
     onRoundStart?.(round)
 
     // The loop is the same whoever answers; only the call differs.
+    // One oversized result is capped first: it frees hundreds of times more
+    // than dropping old results, and keeps what the model asked for.
+    const capped = truncateOversizedToolResults({
+    	messages, window: contextWindow, truncated: truncatedResults
+    });
+    if (capped.messages !== messages) {
+    	messages = capped.messages;
+    	onContextTruncated?.(truncatedResults.slice());
+    }
+
     // Make room before sending, rather than after being refused. Only old
     // tool results are given up; see evictOldToolResults.
     const room = evictOldToolResults({
@@ -431,7 +444,7 @@ export async function runChatLoop(opts) {
     });
     if (room.messages !== messages) {
     	messages = room.messages;
-    	onContextEvicted?.(evicted.slice());
+    	onContextEvicted?.({ dropped: evicted.slice(), needed: room.needed, window: room.window });
     }
 
     const call = provider === "ollama" ? ollamaChatCall : singleLlmCall
@@ -1003,6 +1016,55 @@ export function estimateToolsTokens(tools) {
   return estimateTextTokens(text)
 }
 
+// A single tool result may use at most this share of the window.
+//
+// Measured over 179 real tool results (2026-10-17): the median is 2.1% of the
+// window and the 90th percentile 20%, but one `togovar_search_variant` result
+// came to 94% — 120,667 tokens — and alone could not coexist with a
+// conversation. All six over-budget requests in that sample were caused by one
+// oversized result, so capping it clears every one of them while touching only
+// 4.5% of results at all.
+//
+// 40% keeps a useful prefix of even the worst result (42% of it) and still
+// leaves most of the window for the conversation, the schemas and the answer.
+export const MAX_TOOL_RESULT_SHARE = 0.4
+
+// Shortens any single tool result that exceeds that share.
+//
+// This runs BEFORE eviction, because it is strictly the better move: on the
+// audited turn it frees ~69,000 tokens from one result, where dropping the
+// oldest results freed 160 and lost two results the model had asked for. The
+// model is told what happened, in the result itself, so it can narrow its
+// query instead of assuming it received everything.
+export function truncateOversizedToolResults({ messages, window,
+                                               share = MAX_TOOL_RESULT_SHARE,
+                                               truncated = [] } = {}) {
+  if (!window || !Number.isFinite(window)) return { messages, truncated }
+
+  const cap = Math.floor(window * share)
+  let out = null
+
+  ;(messages || []).forEach((m, i) => {
+    if (m?.role !== "tool" || typeof m.content !== "string") return
+    const tokens = estimateTextTokens(m.content)
+    if (tokens <= cap) return
+
+    // Scale the cut by the measured ratio rather than a fixed chars-per-token,
+    // so a dense result is cut by what it actually costs.
+    const keep = Math.max(1, Math.floor(m.content.length * cap / tokens))
+    out = out || messages.slice()
+    truncated.push({ name: m.name, fromTokens: tokens, toTokens: cap })
+    out[i] = Object.assign({}, m, {
+      content: m.content.slice(0, keep) +
+        "\n\n[truncated: " + keep + " of " + m.content.length + " characters shown. " +
+        "One tool result may use at most " + Math.round(share * 100) +
+        "% of the context window. Call the tool again with a narrower query to see more.]"
+    })
+  })
+
+  return { messages: out || messages, truncated }
+}
+
 // Makes room for the next round by dropping the OLDEST tool results, which is
 // the one eviction a chat loop can justify: the model has already read them and
 // said what it made of them in the assistant turn that follows, so its own
@@ -1021,7 +1083,12 @@ export function evictOldToolResults({ messages, window, reserve = 0, dropped = [
   if (!window || !Number.isFinite(window)) return { messages, dropped }
 
   const budget = window - reserve
-  if (estimateTokens(messages) <= budget) return { messages, dropped }
+  // What the whole turn would have needed, against what the model holds. The
+  // panel shows both, because "an old result was dropped" on its own tells a
+  // reader nothing about whether to retry, shorten the question, or change
+  // model.
+  const needed = estimateTokens(messages) + reserve
+  if (estimateTokens(messages) <= budget) return { messages, dropped, needed, window }
 
   const out = messages.slice()
   for (let i = 0; i < out.length; i++) {
@@ -1036,7 +1103,7 @@ export function evictOldToolResults({ messages, window, reserve = 0, dropped = [
                "if you still need it, with a narrower query.]"
     })
   }
-  return { messages: out, dropped }
+  return { messages: out, dropped, needed, window }
 }
 
 export function modelWindowFrom(payload, modelId) {

data/lib/llm_meta_widget/version.rb

@@ -1,3 +1,3 @@
 module LlmMetaWidget
-  VERSION = "0.12.1"
+  VERSION = "0.12.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_meta_widget
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.12.2
 platform: ruby
 authors:
 - jdkim