llm_meta_widget 0.12.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2ba425d2cce6f582baf43df6ca5512bd344ccd78f1e74b56887eb6f3ccdaff6
-  data.tar.gz: a0127db4a9a59f6a88c052e9f6d54d1d0664c168c4de6cd16fe480fa95a73327
+  metadata.gz: 9d3172a4471dd7326d3455cbb4d39ed5f19092df52e81828b98d71a0c541da57
+  data.tar.gz: 1ec235057d668445bcb40cdb6b584cc73c1c579ee54c2cf36b7bcef699efb5b9
 SHA512:
-  metadata.gz: 7b3d3ddd173ef207ccd651ef5a455ffbdc2941fd0d00bc9e1bce687d824cf789b14b8e0d09f898fbfc0db132d4e384cdb7637289467c3259d180f7e71fdd1c16
-  data.tar.gz: eea0ceefa6b8cecc7472d754c16d0de51a04ad92afb69dfe237c31c1448873761d7a1c7fa90c317fc9b29c568c4c2eecf7fe3f7dead0b467e1e9d68b93dafd57
+  metadata.gz: 1dcda012841f3a4c1f253c837d1149292f0c19cdc6a5396cb7ab7064bfb0ac0dbae5414bc0e33529fb925a4d5b15de28a78cda13bba26bf4856fca84f13a94e2
+  data.tar.gz: 338955619e9f6712e6889bbe62a295de75b7cf9cb6571d7cd9aab0ac227b52caf5d6c891b14ef136bcc115e6da0f721f441b4a9a7bd3be96248d55cde441870e

data/CHANGELOG.md

@@ -3,6 +3,88 @@
 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
+
+The turn was sized at roughly four characters per token, which is right for
+prose and badly wrong for a tool result. A request of 289,101 characters that
+the provider counted as 135,291 tokens was estimated at 72,275 — 53% of its
+real size — so nothing was given up and the provider refused the turn with its
+own error text. That request was 33% letters, 16% digits and 45% punctuation:
+JSON, which tokenizes about twice as densely as prose.
+
+Characters are now counted in three classes — letters and spaces, CJK, and
+everything else — which puts that request at 106% of its real size. Erring
+high is deliberate here: underestimating ends the turn, while overestimating
+gives up an old tool result slightly early. Tool schemas are counted the same
+way, since a schema is JSON too.
+
+### Fixed: following the output no longer fights a reader who scrolls
+
+0.12.0 decided whether to follow the output from the `scroll` event. A browser
+dispatches that event a frame after the position changes, while deltas arrive
+every few milliseconds, so a delta could pin the view before the listener
+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 had a
+different cause, fixed in 0.12.2 below.
+
 ## 0.12.0
 
 Nothing a page must provide changes in this release: no new attribute, no

data/README.md

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

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

@@ -168,15 +168,17 @@ function boot(cfg) {
   	// The reader's own scrolling says which they are doing: leave the bottom
   	// 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"
-  	var followingOutput  = true;
+
+  	// 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;
   	}
   	function pinToBottom() { historyEl.scrollTop = historyEl.scrollHeight; }
-  	// Called wherever content is added mid-turn.
-  	function pinIfFollowing() { if (followingOutput) pinToBottom(); }
-  	historyEl.addEventListener("scroll", function() { followingOutput = atBottom(); });
   	var formEl       = root.querySelector(".lmw-form");
   	var inputEl      = root.querySelector(".lmw-input");
   	var clearBtn     = root.querySelector(".lmw-clear");
@@ -935,6 +937,8 @@ function boot(cfg) {
   	var pendingTurnLabel = null;
 
   	function appendTurn(role, text, turnLabel) {
+  		// Captured BEFORE anything is added: see atBottom.
+  		var following = atBottom();   // a question always wins
   		// Class names mirror llm_meta_chat's chats/_message.html.erb —
   		// `.message.<role>`, `.message-role`, `.message-content` — so the
   		// shared conversation.css styles apply directly (see the <link>
@@ -973,7 +977,9 @@ function boot(cfg) {
   		div.appendChild(document.createTextNode(" "));
   		div.appendChild(body);
   		historyEl.appendChild(div);
-  		pinIfFollowing();
+  		// A question the visitor just asked always goes to the end; anything
+  		// else respects where they were reading.
+  		if (role === "user" || following) pinToBottom();
   		body.roleLabel = label;   // so a turn in flight can show it is working
   		return body;
   	}
@@ -1061,6 +1067,8 @@ function boot(cfg) {
   	}
 
   	function announceToolCall(toolCall) {
+  		// Captured BEFORE anything is added: see atBottom.
+  		var following = atBottom();
   		var row = chipRow();
   		if (!row) return;
   		var chip = document.createElement("span");
@@ -1069,7 +1077,7 @@ function boot(cfg) {
   		chip.dataset.tool = toolCall.name;
   		row.appendChild(chip);
   		pendingChips.push(chip);
-  		pinIfFollowing();
+  		if (following) pinToBottom();
   	}
 
   	function resolveToolCall(outcome) {
@@ -1091,6 +1099,8 @@ function boot(cfg) {
   	var activeAssistantBody  = null;
 
   	function ensureThinkingBlock() {
+  		// Captured BEFORE anything is added: see atBottom.
+  		var following = atBottom();
   		if (currentThinkingBody) return currentThinkingBody;
   		// Class names match llm_meta_chat's .message-thinking pattern so
   		// the shared conversation.css applies directly.
@@ -1117,21 +1127,51 @@ function boot(cfg) {
   		} else {
   			historyEl.appendChild(details);
   		}
-  		pinIfFollowing();
+  		if (following) pinToBottom();
   		currentThinkingBlock = details;
   		currentThinkingBody  = body;
   		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
@@ -1266,9 +1306,6 @@ function boot(cfg) {
   		var userText = inputEl.value.trim();
   		if (!userText) return;
   		inputEl.value = "";
-  		// Asking something is a request to see the answer: whatever the reader was
-  		// looking at before, they are following the output again from here.
-  		followingOutput = true;
   		appendTurn("user", userText, pendingTurnLabel);
   		pendingTurnLabel = null;
 
@@ -1316,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);
@@ -1356,19 +1412,23 @@ function boot(cfg) {
   					collapseThinkingBlock();
   				},
   				onThinkingDelta: function(delta) {
+  					// Captured BEFORE anything is added: see atBottom.
+  					var following = atBottom();
   					var body = ensureThinkingBlock();
   					body.appendChild(document.createTextNode(delta));
   					body.scrollTop = body.scrollHeight;
-  					pinIfFollowing();
+  					if (following) pinToBottom();
   				},
   				onTextDelta: function(delta) {
+  					// Captured BEFORE anything is added: see atBottom.
+  					var following = atBottom();
   					markDone(assistantBody.roleLabel);
   					collapseThinkingBlock();
   					assistantMarkdown += delta;
   					renderMarkdownInto(assistantBody, assistantMarkdown);
   					liveTurn.content = assistantMarkdown;
   					persistSoon();
-  					pinIfFollowing();
+  					if (following) pinToBottom();
   				}
   			});
   			// The turn was recorded here until 0.11.1, after the loop returned — which

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({
@@ -589,17 +601,29 @@ function parseSseFrame(raw) {
 var STATIC_PRIMITIVES_META = "io.modelcontextprotocol/static-primitives";
 var PAGE_CARD_MEDIA_TYPE = "application/mcp-static-primitives+json";
 var RESOURCE_SHARE_OF_WINDOW = 0.0625;
+var RESOURCE_BYTES_PER_TOKEN = 4;
 function resourceBudgetBytes(window2, { floor = 8e3, cap = 64e3 } = {}) {
   if (!window2 || !Number.isFinite(window2)) return floor;
-  const share = Math.round(window2 * RESOURCE_SHARE_OF_WINDOW * CHARS_PER_TOKEN);
+  const share = Math.round(window2 * RESOURCE_SHARE_OF_WINDOW * RESOURCE_BYTES_PER_TOKEN);
   return Math.min(cap, Math.max(floor, share));
 }
-var CHARS_PER_TOKEN = 4;
+var PROSE_CHARS_PER_TOKEN = 3.5;
+var DENSE_CHARS_PER_TOKEN = 1.6;
+var CJK_CHARS_PER_TOKEN = 1;
 var MESSAGE_OVERHEAD_TOKENS = 4;
+var CJK_PATTERN = /[\u3000-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]/g;
+var PROSE_PATTERN = /[A-Za-z \n\t]/g;
+function estimateTextTokens(text) {
+  const str = typeof text === "string" ? text : String(text ?? "");
+  const cjk = (str.match(CJK_PATTERN) || []).length;
+  const prose = (str.match(PROSE_PATTERN) || []).length;
+  const dense = str.length - cjk - prose;
+  return Math.ceil(cjk / CJK_CHARS_PER_TOKEN + prose / PROSE_CHARS_PER_TOKEN + dense / DENSE_CHARS_PER_TOKEN);
+}
 function estimateTokens(messages) {
   return (messages || []).reduce((sum, m) => {
     const content = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content ?? "");
-    return sum + Math.ceil(content.length / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD_TOKENS;
+    return sum + estimateTextTokens(content) + MESSAGE_OVERHEAD_TOKENS;
   }, 0);
 }
 function estimateToolsTokens(tools) {
@@ -608,12 +632,36 @@ function estimateToolsTokens(tools) {
     description: t?.description,
     schema: t?.input_schema || t?.inputSchema
   })).join("");
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
+  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;
@@ -625,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 || []) {
@@ -3940,19 +3988,15 @@ function boot(cfg) {
   var toggleBtn = document.getElementById("llm-meta-widget-toggle");
   var historyEl = root.querySelector(".lmw-messages");
   var SCROLL_PIN_SLACK = 40;
-  var followingOutput = true;
+  function thousands(n) {
+    return (Math.round(n / 1e3) * 1e3).toLocaleString("en-US");
+  }
   function atBottom() {
     return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
   }
   function pinToBottom() {
     historyEl.scrollTop = historyEl.scrollHeight;
   }
-  function pinIfFollowing() {
-    if (followingOutput) pinToBottom();
-  }
-  historyEl.addEventListener("scroll", function() {
-    followingOutput = atBottom();
-  });
   var formEl = root.querySelector(".lmw-form");
   var inputEl = root.querySelector(".lmw-input");
   var clearBtn = root.querySelector(".lmw-clear");
@@ -4505,6 +4549,7 @@ function boot(cfg) {
   }
   var pendingTurnLabel = null;
   function appendTurn(role, text, turnLabel) {
+    var following = atBottom();
     var welcome = historyEl.querySelector(".lmw-welcome");
     if (welcome) welcome.remove();
     var div = document.createElement("div");
@@ -4531,7 +4576,7 @@ function boot(cfg) {
     div.appendChild(document.createTextNode(" "));
     div.appendChild(body);
     historyEl.appendChild(div);
-    pinIfFollowing();
+    if (role === "user" || following) pinToBottom();
     body.roleLabel = label;
     return body;
   }
@@ -4581,6 +4626,7 @@ function boot(cfg) {
     return liveChips;
   }
   function announceToolCall(toolCall) {
+    var following = atBottom();
     var row = chipRow();
     if (!row) return;
     var chip = document.createElement("span");
@@ -4589,7 +4635,7 @@ function boot(cfg) {
     chip.dataset.tool = toolCall.name;
     row.appendChild(chip);
     pendingChips.push(chip);
-    pinIfFollowing();
+    if (following) pinToBottom();
   }
   function resolveToolCall(outcome) {
     var idx = pendingChips.findIndex(function(c) {
@@ -4605,6 +4651,7 @@ function boot(cfg) {
   var currentThinkingBody = null;
   var activeAssistantBody = null;
   function ensureThinkingBlock() {
+    var following = atBottom();
     if (currentThinkingBody) return currentThinkingBody;
     var details = document.createElement("details");
     details.className = "message-thinking";
@@ -4629,20 +4676,33 @@ function boot(cfg) {
     } else {
       historyEl.appendChild(details);
     }
-    pinIfFollowing();
+    if (following) pinToBottom();
     currentThinkingBlock = details;
     currentThinkingBody = body;
     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] || {};
@@ -4746,7 +4806,6 @@ function boot(cfg) {
     var userText = inputEl.value.trim();
     if (!userText) return;
     inputEl.value = "";
-    followingOutput = true;
     appendTurn("user", userText, pendingTurnLabel);
     pendingTurnLabel = null;
     if (currentAbort) {
@@ -4786,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);
@@ -4809,19 +4876,21 @@ function boot(cfg) {
           collapseThinkingBlock();
         },
         onThinkingDelta: function(delta) {
+          var following = atBottom();
           var body = ensureThinkingBlock();
           body.appendChild(document.createTextNode(delta));
           body.scrollTop = body.scrollHeight;
-          pinIfFollowing();
+          if (following) pinToBottom();
         },
         onTextDelta: function(delta) {
+          var following = atBottom();
           markDone(assistantBody.roleLabel);
           collapseThinkingBlock();
           assistantMarkdown += delta;
           renderMarkdownInto(assistantBody, assistantMarkdown);
           liveTurn.content = assistantMarkdown;
           persistSoon();
-          pinIfFollowing();
+          if (following) pinToBottom();
         }
       });
       liveTurn.content = result.content;

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
@@ -937,23 +950,53 @@ export const PAGE_CARD_MEDIA_TYPE = "application/mcp-static-primitives+json"
 // is already generous and a 1M-token model does not need 250 KB of it.
 export const RESOURCE_SHARE_OF_WINDOW = 0.0625
 
+// Bytes per token for SIZING that budget — not the estimator above, which
+// measures real text. Kept at four so the budget stays exactly what it was
+// (8 KB on a 32k model): how many tokens those bytes become depends on the
+// resource, and re-sizing budgets is not this constant's job.
+export const RESOURCE_BYTES_PER_TOKEN = 4
+
 export function resourceBudgetBytes(window, { floor = 8000, cap = 64_000 } = {}) {
   if (!window || !Number.isFinite(window)) return floor
-  const share = Math.round(window * RESOURCE_SHARE_OF_WINDOW * CHARS_PER_TOKEN)
+  const share = Math.round(window * RESOURCE_SHARE_OF_WINDOW * RESOURCE_BYTES_PER_TOKEN)
   return Math.min(cap, Math.max(floor, share))
 }
 
-// A rough token count, the same shape the hub's own estimator uses: characters
-// over four, plus a fixed cost per message. Deliberately approximate — it is
-// used to decide "drop the oldest tool result", never to fill the window
-// exactly, and it errs high so the decision is made early rather than late.
-export const CHARS_PER_TOKEN = 4
+// A rough token count, the same three classes the hub's estimator uses.
+//
+// One ratio cannot describe both prose and a tool result. Letters and spaces
+// tokenize at roughly 3.5 characters each; digits, punctuation and symbols go
+// much denser, and a JSON tool result is mostly those.
+//
+// Measured against a real refusal (2026-10-17): a 289,101-character request
+// the provider counted as 135,291 tokens was 33% letters, 16% digits and 45%
+// punctuation. At a flat four characters per token that is 72,275 — 53% of the
+// truth — so nothing was evicted and the provider refused the turn instead.
+// These classes put it at 106%: high, which is the safe direction here, since
+// underestimating means the turn dies while overestimating only gives up an
+// old tool result slightly early.
+export const PROSE_CHARS_PER_TOKEN = 3.5
+export const DENSE_CHARS_PER_TOKEN = 1.6
+export const CJK_CHARS_PER_TOKEN = 1
 export const MESSAGE_OVERHEAD_TOKENS = 4
 
+const CJK_PATTERN = /[\u3000-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]/g
+const PROSE_PATTERN = /[A-Za-z \n\t]/g
+
+export function estimateTextTokens(text) {
+  const str = typeof text === "string" ? text : String(text ?? "")
+  const cjk = (str.match(CJK_PATTERN) || []).length
+  const prose = (str.match(PROSE_PATTERN) || []).length
+  const dense = str.length - cjk - prose
+  return Math.ceil(cjk / CJK_CHARS_PER_TOKEN +
+                   prose / PROSE_CHARS_PER_TOKEN +
+                   dense / DENSE_CHARS_PER_TOKEN)
+}
+
 export function estimateTokens(messages) {
   return (messages || []).reduce((sum, m) => {
     const content = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content ?? "")
-    return sum + Math.ceil(content.length / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD_TOKENS
+    return sum + estimateTextTokens(content) + MESSAGE_OVERHEAD_TOKENS
   }, 0)
 }
 
@@ -969,7 +1012,57 @@ export function estimateToolsTokens(tools) {
   const text = (tools || []).map((t) => JSON.stringify({
     name: t?.name, description: t?.description, schema: t?.input_schema || t?.inputSchema
   })).join("")
-  return Math.ceil(text.length / CHARS_PER_TOKEN)
+  // Counted with the same classes: a schema is JSON, which is the dense case.
+  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
@@ -990,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++) {
@@ -1005,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.0"
+  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.0
+  version: 0.12.2
 platform: ruby
 authors:
 - jdkim