llm_meta_widget 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 845c38baf1aca6cc874a77c9f324895c6001664dffe4d891d8b31ed2057a3b2b
-  data.tar.gz: 825acda8a84c599e09e8d11cad9fe738092aa807b41911a99889e76dab15c800
+  metadata.gz: 98514af704b8e59db0091c55a0d42f60cc3d9da77ed8debbf8aa2b94e514576d
+  data.tar.gz: e0b25d087956a31ad5bc21ce232b25abe1aa0ca78a917abdaf6f0e97c7ba7237
 SHA512:
-  metadata.gz: 0244dc664c60f88e1cf29e9cb52ebc9e33bf61e8ab2ab180a8e0873d587bf1cf96d8865eeb9d97b0fe325cec00c43e6e154cef74c511f7f16894a2112d17ad23
-  data.tar.gz: 5584f49e2c7e848ef93fdb5bf6cb1270fa3154f77beee255eb64e221aab20ce8e4828b4b8381c5268e1503b1b0967d4fab81811be718f23f247951ccdf1c142a
+  metadata.gz: 15101bd9cbac468ccc0c2f5e7e5206e153a459335954779f80694e7431713aa5835849b4b9278511df408bd237adc37cfc16ef658b7a85b279b23d6871eb46d8
+  data.tar.gz: e81e6404165550d0521eb1fba9aa18d4e10ebc0cac400f50e6ff9453084f84e082baba1f7b386155d0b0d567c2a0e51e6de93d16a6a80fba0260f949ad1460d7

data/CHANGELOG.md

@@ -3,6 +3,109 @@
 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.13.0
+
+### Changed: a page card declares its transport in `transports`, not `remotes`
+
+The declaration that says how to reach a page's handlers has moved, following
+SEP revision d44bd25a. It is now an array inside the extension data:
+
+```json
+{
+  "_meta": {
+    "io.modelcontextprotocol/static-primitives": {
+      "transports": [ { "type": "page-global", "global": "mcp" } ],
+      "tools": [], "prompts": [], "resources": []
+    }
+  }
+}
+```
+
+The reason is that the Server Card's `Remote.type` can only be
+`streamable-http` or `sse`, so `page-global` was never a valid value at the top
+level. It is an array because a page may come to offer more than one page-local
+transport, and the order is the author's preference.
+
+The widget reads the array in order and uses the first type it supports. It
+will not skip a supported entry for a later one. Only `page-global` is
+supported today; a card offering only `page-postmessage`, `page-jsonrpc` or
+`page-worker` gets no handlers rather than the wrong ones, and says so.
+
+**Top-level `remotes` still works in this release**, with a warning, so a page
+and a widget can be updated in either order without the page losing its tools
+in between. Move to `transports`; a later release will drop the fallback. If a
+page declares both, `transports` decides and nothing is reported.
+
+
+### Added: the panel says when reference data did not fit
+
+A resource refused by the budget used to disappear with nothing but a line in
+the browser console: the model answered from less than the page offered, and
+nobody was told. The panel now reports it, naming the resource, its size and
+what the model allows — once per budget, on the first turn it affects, and
+again if a different model changes the figures.
+
+The model is deliberately NOT told. It cannot fetch a resource — only the
+client reads those — so telling it would spend context on something it can do
+nothing about. The reader can act: choose a model with a larger window, or ask
+the page author for a smaller reference.
+
+A resource the page withholds on purpose (`autoAttach: false`) is not reported,
+since that is the author's choice rather than an omission.
+
+## 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 +132,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.13.0"
 ```
 
 ```bash
@@ -152,23 +152,27 @@ The widget is a custom element in a single self-contained ES module, so the
 whole integration is two lines of HTML:
 
 ```html
-<script type="module" src="https://cdn.jsdelivr.net/npm/@aibranch/llm-meta-widget@0.12"></script>
+<script type="module" src="https://cdn.jsdelivr.net/npm/@aibranch/llm-meta-widget@0.13"></script>
 <llm-meta-widget llm-url="https://your-meta-server.example"
                  model="gpt-oss-120b"
                  greeting="Hi — ask me anything about this page."></llm-meta-widget>
 ```
 
-**`@0.12` is a version range, and it stops at 0.12.x on purpose.** You receive
+**`@0.13` is a version range, and it stops at 0.13.x on purpose.** You receive
 bug fixes without editing your page, and a release that breaks your page cannot
 arrive on its own.
 
-Moving to 0.13 is therefore a change you make yourself. Read
+Moving to 0.14 is therefore a change you make yourself. Read
 [CHANGELOG.md](CHANGELOG.md) before you do, because this is where what your page
 must provide can change. For example, 0.10.0 changed how the widget finds a page
 card: by media type rather than by element id. A page that declared its card the
 new way while still loading `@0.9` lost every tool, prompt and resource it had
 declared. Nothing failed, anywhere. The CHANGELOG entry for 0.10.0 describes it.
 
+0.13.0 moves where a page declares its transport. That one is safe to take
+first, because 0.13.x still reads the old spelling and warns; the page can move
+afterwards.
+
 A Rails app is protected from that mismatch, because the `Gemfile` will not
 resolve a widget version the page cannot use. A page that loads the widget from
 the CDN has no such check, so the version you write in that URL is the only

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

@@ -169,6 +169,40 @@ 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.
+  	// Reference data the budget refused, so the panel can say so on the next
+	// turn. NOT announced at boot: appendTurn persists, so a boot-time notice
+	// would be saved into the transcript and repeat on every reload.
+	//
+	// The model is not told, deliberately. It cannot fetch a resource — only the
+	// client reads those — so telling it would spend tokens on something it can
+	// do nothing about. The person CAN act: pick a model with more room, or ask
+	// the page author for a smaller reference.
+	var skippedResources = [];
+	var announcedSkips   = false;
+
+	function kb(bytes) { return Math.round((bytes || 0) / 1024) + " KB"; }
+
+	// `origin` is "page" for a page-card resource and "host" for one from a
+	// host-wide server. It matters when the budget changes: page resources are
+	// planned again, so their refusals are re-recorded, while a host resource is
+	// listed once at boot and never re-planned. Clearing both on a re-plan
+	// erased the host refusal before it could be reported — which silenced the
+	// case that matters most, since PubDictionaries' catalog arrives that way.
+	function noteSkippedResource(plan, budget, origin) {
+		// A resource the page marked autoAttach:false is a deliberate choice, not
+		// an omission — only a budget refusal is worth reporting.
+		if (plan.reason !== "over-budget") return;
+		var name = plan.name || plan.uri;
+		skippedResources = skippedResources.filter(function(s) { return s.name !== name; });
+		skippedResources.push({ name: name, size: plan.size, budget: budget, origin: origin });
+	}
+
+	function thousands(n) {
+  		return (Math.round(n / 1000) * 1000).toLocaleString("en-US");
+  	}
+
   	function atBottom() {
   		return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
   	}
@@ -695,12 +729,19 @@ function boot(cfg) {
   		var budget = resourceBudget();
   		if (pageResourcePlans === null || budget !== pageResourcePlansBudget) {
   			pageResourcePlansBudget = budget;
+			// A different budget is a different decision: say it again. Only the
+			// page's own refusals are dropped — those are about to be re-recorded
+			// by the planning below. A host resource is listed once at boot, so
+			// discarding its refusal here would lose it for good.
+			skippedResources = skippedResources.filter(function(s) { return s.origin !== "page"; });
+			announcedSkips   = false;
   			pageResourcePlans = planPageResources({
   				entries:     pageCard.resources,
   				budgetBytes: budget,
   				onSkip: function(plan) {
   					console.info("[llm_meta_widget] not attaching " + plan.uri +
   					             " (" + plan.reason + ", size=" + plan.size + ")");
+  					             noteSkippedResource(plan, resourceBudget(), "page");
   				}
   			});
   		}
@@ -753,6 +794,7 @@ function boot(cfg) {
   					onSkip: function(plan) {
   						console.info("[llm_meta_widget] not attaching " + plan.uri +
   						             " (" + plan.reason + ", size=" + plan.size + ")");
+  						             noteSkippedResource(plan, resourceBudget(), "host");
   					}
   				});
   				// A volatile resource comes back with no context — it is read
@@ -1127,15 +1169,48 @@ 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.
+	// https://issues.chromium.org/issues/574960594 — docs/chromium-scroll-bug.md has the
+	// measurements and a self-checking test case. Remove this once the fix
+	// has shipped widely enough.
+  	//
+  	// 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
@@ -1271,6 +1346,23 @@ function boot(cfg) {
   		if (!userText) return;
   		inputEl.value = "";
   		appendTurn("user", userText, pendingTurnLabel);
+
+  		// Reference data that did not fit, reported once per budget, at the moment
+  		// it affects an answer rather than at boot.
+  		// Plan the page's resources first: the refusals are recorded while planning,
+  		// which otherwise happens later in the turn — after this check had already
+  		// looked at an empty list and said nothing.
+  		pageResourcePlansNow();
+  		if (skippedResources.length && !announcedSkips) {
+  			announcedSkips = true;
+  			var skipped = skippedResources[0];
+  			var others = skippedResources.length - 1;
+  			var alsoText = others > 0 ? " and " + others + " other reference" + (others > 1 ? "s" : "") : "";
+  			appendTurn("system", "Did not attach the " + skipped.name + " reference" + alsoText +
+  				" (" + kb(skipped.size) + ", and a " + MODEL + " turn allows " + kb(skipped.budget) +
+  				" for reference data), so the answer may be less precise." +
+  				" A model with a larger context window would make room.");
+  		}
   		pendingTurnLabel = null;
 
   		if (currentAbort) { try { currentAbort.abort(); } catch (e) { /* noop */ } }
@@ -1317,12 +1409,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 || []) {
@@ -653,15 +689,29 @@ function modelWindowFrom(payload, modelId) {
   return null;
 }
 var PAGE_GLOBAL_TRANSPORT = "page-global";
-function declaredPageGlobal(card) {
+function declaredPageGlobal(card, warn = console.warn) {
+  const declared = card && card.transports || [];
+  for (const transport of declared) {
+    if (!transport || transport.type !== PAGE_GLOBAL_TRANSPORT) continue;
+    if (typeof transport.global === "string" && transport.global.trim() !== "") {
+      return transport.global.trim();
+    }
+  }
+  if (declared.length) {
+    warn("[llm-meta-widget] page card declares transports " + JSON.stringify(declared.map((t) => t && t.type)) + ", none of which this widget supports; not dispatching to the page");
+    return null;
+  }
   for (const remote of card && card.remotes || []) {
     if (!remote || remote.type !== PAGE_GLOBAL_TRANSPORT) continue;
-    if (typeof remote.global === "string" && remote.global.trim() !== "") return remote.global.trim();
+    if (typeof remote.global === "string" && remote.global.trim() !== "") {
+      warn(`[llm-meta-widget] page card declares its transport in top-level "remotes", which is deprecated; move it to _meta["${STATIC_PRIMITIVES_META}"].transports`);
+      return remote.global.trim();
+    }
   }
   return null;
 }
 function pageHandlers({ card, scope = {}, legacy = {}, warn = console.warn } = {}) {
-  const name = declaredPageGlobal(card);
+  const name = declaredPageGlobal(card, warn);
   const declared = name ? scope[name] : null;
   if (name && !declared) {
     warn(`[llm-meta-widget] the page card declares global "${name}", but window.${name} is not defined \u2014 is the script that defines it loaded, and did it run?`);
@@ -683,16 +733,19 @@ function pageHandlers({ card, scope = {}, legacy = {}, warn = console.warn } = {
   };
 }
 function mergeStaticPrimitivesCards(cards, warn = console.warn) {
-  const merged = { remotes: [], tools: [], prompts: [], resources: [] };
+  const merged = { transports: [], remotes: [], tools: [], prompts: [], resources: [] };
   for (const card of cards || []) {
-    for (const remote of card && card.remotes || []) {
-      const clash = merged.remotes.find((r) => r.type === remote.type && r.global !== remote.global);
-      if (clash) {
-        warn(`[llm-meta-widget] two blocks declare different ${remote.type} globals ("${clash.global}" and "${remote.global}"); using "${clash.global}"`);
-        continue;
-      }
-      if (!merged.remotes.some((r) => r.type === remote.type && r.global === remote.global)) {
-        merged.remotes.push(remote);
+    for (const kind of ["transports", "remotes"]) {
+      for (const entry of card && card[kind] || []) {
+        if (!entry || typeof entry.type !== "string") continue;
+        const clash = merged[kind].find((r) => r.type === entry.type && r.global !== entry.global);
+        if (clash) {
+          warn(`[llm-meta-widget] two blocks declare different ${entry.type} globals ("${clash.global}" and "${entry.global}"); using "${clash.global}"`);
+          continue;
+        }
+        if (!merged[kind].some((r) => r.type === entry.type && r.global === entry.global)) {
+          merged[kind].push(entry);
+        }
       }
     }
   }
@@ -713,7 +766,7 @@ function mergeStaticPrimitivesCards(cards, warn = console.warn) {
   return merged;
 }
 function readStaticPrimitivesCard(text, warn = console.warn) {
-  const empty = { remotes: [], tools: [], prompts: [], resources: [] };
+  const empty = { transports: [], remotes: [], tools: [], prompts: [], resources: [] };
   if (typeof text !== "string" || text.trim() === "") return empty;
   let doc;
   try {
@@ -733,7 +786,12 @@ function readStaticPrimitivesCard(text, warn = console.warn) {
     return ok;
   });
   return {
-    // The whole card's transport, so what it declares survives the parse.
+    // Where a page says how to reach its handlers. Since SEP d44bd25a this is
+    // `transports` inside the extension data, because the Server Card's
+    // `Remote.type` enum is streamable-http|sse and `page-global` was never a
+    // valid value there. Top-level `remotes` is what 0.11.1-0.12.2 read, and is
+    // still accepted for one release — see declaredPageGlobal.
+    transports: Array.isArray(ext.transports) ? ext.transports : [],
     remotes: Array.isArray(doc.remotes) ? doc.remotes : [],
     tools: named(ext.tools, "tool"),
     prompts: named(ext.prompts, "prompt"),
@@ -3952,6 +4010,22 @@ function boot(cfg) {
   var toggleBtn = document.getElementById("llm-meta-widget-toggle");
   var historyEl = root.querySelector(".lmw-messages");
   var SCROLL_PIN_SLACK = 40;
+  var skippedResources = [];
+  var announcedSkips = false;
+  function kb(bytes) {
+    return Math.round((bytes || 0) / 1024) + " KB";
+  }
+  function noteSkippedResource(plan, budget, origin) {
+    if (plan.reason !== "over-budget") return;
+    var name = plan.name || plan.uri;
+    skippedResources = skippedResources.filter(function(s) {
+      return s.name !== name;
+    });
+    skippedResources.push({ name, size: plan.size, budget, origin });
+  }
+  function thousands(n) {
+    return (Math.round(n / 1e3) * 1e3).toLocaleString("en-US");
+  }
   function atBottom() {
     return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
   }
@@ -4343,11 +4417,16 @@ function boot(cfg) {
     var budget = resourceBudget();
     if (pageResourcePlans === null || budget !== pageResourcePlansBudget) {
       pageResourcePlansBudget = budget;
+      skippedResources = skippedResources.filter(function(s) {
+        return s.origin !== "page";
+      });
+      announcedSkips = false;
       pageResourcePlans = planPageResources({
         entries: pageCard.resources,
         budgetBytes: budget,
         onSkip: function(plan) {
           console.info("[llm_meta_widget] not attaching " + plan.uri + " (" + plan.reason + ", size=" + plan.size + ")");
+          noteSkippedResource(plan, resourceBudget(), "page");
         }
       });
     }
@@ -4378,6 +4457,7 @@ function boot(cfg) {
           read: readMcpResource,
           onSkip: function(plan) {
             console.info("[llm_meta_widget] not attaching " + plan.uri + " (" + plan.reason + ", size=" + plan.size + ")");
+            noteSkippedResource(plan, resourceBudget(), "host");
           }
         });
         if (loaded && loaded.plan && loaded.plan.fetch) {
@@ -4643,14 +4723,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] || {};
@@ -4755,6 +4848,14 @@ function boot(cfg) {
     if (!userText) return;
     inputEl.value = "";
     appendTurn("user", userText, pendingTurnLabel);
+    pageResourcePlansNow();
+    if (skippedResources.length && !announcedSkips) {
+      announcedSkips = true;
+      var skipped = skippedResources[0];
+      var others = skippedResources.length - 1;
+      var alsoText = others > 0 ? " and " + others + " other reference" + (others > 1 ? "s" : "") : "";
+      appendTurn("system", "Did not attach the " + skipped.name + " reference" + alsoText + " (" + kb(skipped.size) + ", and a " + MODEL + " turn allows " + kb(skipped.budget) + " for reference data), so the answer may be less precise. A model with a larger context window would make room.");
+    }
     pendingTurnLabel = null;
     if (currentAbort) {
       try {
@@ -4793,10 +4894,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) {
@@ -1055,10 +1122,41 @@ export function modelWindowFrom(payload, modelId) {
 
 export const PAGE_GLOBAL_TRANSPORT = "page-global"
 
-export function declaredPageGlobal(card) {
+// Which JS global holds the handlers, from the card's declared transports.
+//
+// The array is processed IN ORDER and the first entry whose type we support
+// wins: the page author's order is their preference, so a supported entry is
+// never skipped for a later one. Only `page-global` is supported today;
+// `page-postmessage`, `page-jsonrpc` and `page-worker` are reserved, and a card
+// declaring only those gets no handlers rather than the wrong ones.
+//
+// Top-level `remotes` is the pre-d44bd25a shape that 0.11.1 and 0.12.2 read. It
+// is accepted for one release so a page and a widget can be updated in either
+// order without the page going dark in between, and it warns so the author
+// knows to move.
+export function declaredPageGlobal(card, warn = console.warn) {
+  const declared = (card && card.transports) || []
+  for (const transport of declared) {
+    if (!transport || transport.type !== PAGE_GLOBAL_TRANSPORT) continue
+    if (typeof transport.global === "string" && transport.global.trim() !== "") {
+      return transport.global.trim()
+    }
+  }
+  if (declared.length) {
+    warn("[llm-meta-widget] page card declares transports " +
+         JSON.stringify(declared.map((t) => t && t.type)) +
+         ", none of which this widget supports; not dispatching to the page")
+    return null
+  }
+
   for (const remote of (card && card.remotes) || []) {
     if (!remote || remote.type !== PAGE_GLOBAL_TRANSPORT) continue
-    if (typeof remote.global === "string" && remote.global.trim() !== "") return remote.global.trim()
+    if (typeof remote.global === "string" && remote.global.trim() !== "") {
+      warn('[llm-meta-widget] page card declares its transport in top-level ' +
+           '"remotes", which is deprecated; move it to ' +
+           `_meta["${STATIC_PRIMITIVES_META}"].transports`)
+      return remote.global.trim()
+    }
   }
   return null
 }
@@ -1067,7 +1165,7 @@ export function declaredPageGlobal(card) {
 // to its legacy global independently, so a page part-way through moving over
 // keeps working instead of losing the primitives it has not moved yet.
 export function pageHandlers({ card, scope = {}, legacy = {}, warn = console.warn } = {}) {
-  const name = declaredPageGlobal(card)
+  const name = declaredPageGlobal(card, warn)
   const declared = name ? scope[name] : null
 
   // A card that names a global the page never defines is almost always a load
@@ -1112,20 +1210,28 @@ export function pageHandlers({ card, scope = {}, legacy = {}, warn = console.war
 // Picking the first would make which component wins depend on DOM order, which
 // is not something a page author controls when the components are partials.
 export function mergeStaticPrimitivesCards(cards, warn = console.warn) {
-  const merged = { remotes: [], tools: [], prompts: [], resources: [] }
-  // Each block is a full Server Card and may declare a transport. The first
-  // one wins; a second block naming a DIFFERENT global is an authoring error,
-  // because only one of them can be dispatched to.
+  const merged = { transports: [], remotes: [], tools: [], prompts: [], resources: [] }
+  // Each block is a full Server Card and may declare transports. They are
+  // concatenated in document order, because the order is the author's
+  // preference and selection honours it. A second block naming a DIFFERENT
+  // global for the same type is an authoring error — only one of them can be
+  // dispatched to — so the first is kept and the clash is reported.
+  //
+  // `remotes` is merged the same way: it is the deprecated spelling of the same
+  // thing, and a page mid-migration may still carry it.
   for (const card of cards || []) {
-    for (const remote of (card && card.remotes) || []) {
-      const clash = merged.remotes.find((r) => r.type === remote.type && r.global !== remote.global)
-      if (clash) {
-        warn(`[llm-meta-widget] two blocks declare different ${remote.type} globals ` +
-             `("${clash.global}" and "${remote.global}"); using "${clash.global}"`)
-        continue
-      }
-      if (!merged.remotes.some((r) => r.type === remote.type && r.global === remote.global)) {
-        merged.remotes.push(remote)
+    for (const kind of [ "transports", "remotes" ]) {
+      for (const entry of (card && card[kind]) || []) {
+        if (!entry || typeof entry.type !== "string") continue
+        const clash = merged[kind].find((r) => r.type === entry.type && r.global !== entry.global)
+        if (clash) {
+          warn(`[llm-meta-widget] two blocks declare different ${entry.type} globals ` +
+               `("${clash.global}" and "${entry.global}"); using "${clash.global}"`)
+          continue
+        }
+        if (!merged[kind].some((r) => r.type === entry.type && r.global === entry.global)) {
+          merged[kind].push(entry)
+        }
       }
     }
   }
@@ -1151,7 +1257,7 @@ export function mergeStaticPrimitivesCards(cards, warn = console.warn) {
 }
 
 export function readStaticPrimitivesCard(text, warn = console.warn) {
-  const empty = { remotes: [], tools: [], prompts: [], resources: [] }
+  const empty = { transports: [], remotes: [], tools: [], prompts: [], resources: [] }
   if (typeof text !== "string" || text.trim() === "") return empty
 
   let doc
@@ -1175,7 +1281,12 @@ export function readStaticPrimitivesCard(text, warn = console.warn) {
   })
 
   return {
-    // The whole card's transport, so what it declares survives the parse.
+    // Where a page says how to reach its handlers. Since SEP d44bd25a this is
+    // `transports` inside the extension data, because the Server Card's
+    // `Remote.type` enum is streamable-http|sse and `page-global` was never a
+    // valid value there. Top-level `remotes` is what 0.11.1-0.12.2 read, and is
+    // still accepted for one release — see declaredPageGlobal.
+    transports: Array.isArray(ext.transports) ? ext.transports : [],
     remotes: Array.isArray(doc.remotes) ? doc.remotes : [],
     tools: named(ext.tools, "tool"),
     prompts: named(ext.prompts, "prompt"),

data/lib/llm_meta_widget/version.rb

@@ -1,3 +1,3 @@
 module LlmMetaWidget
-  VERSION = "0.12.1"
+  VERSION = "0.13.0"
 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.13.0
 platform: ruby
 authors:
 - jdkim