llm_meta_widget 0.11.1 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7169f9db8dacb339f604b908494879c8db5c32635cbcc76d5cda807eb1e4dfd
-  data.tar.gz: ad8200955697be3b0d5e9f31cc0cde13882213537cf93582e36a612f348b5d4f
+  metadata.gz: 845c38baf1aca6cc874a77c9f324895c6001664dffe4d891d8b31ed2057a3b2b
+  data.tar.gz: 825acda8a84c599e09e8d11cad9fe738092aa807b41911a99889e76dab15c800
 SHA512:
-  metadata.gz: 95b8f1577f51acd48d50fff55c6c28534656ab448041fa3b247230ae6cee3ba06b1046b4e9e8d94af20c570f06bcebaa519a9caac1e81fedd1bd17c433349762
-  data.tar.gz: 6cb12977d3457b7c288242cb1244e0af36dea798df12104a0f1ec6fc5c64acdee95bfb04ed59a5e53e1d9e9e71632bf9e7367bfa8bd10a1e323734f3b9ea2eef
+  metadata.gz: 0244dc664c60f88e1cf29e9cb52ebc9e33bf61e8ab2ab180a8e0873d587bf1cf96d8865eeb9d97b0fe325cec00c43e6e154cef74c511f7f16894a2112d17ad23
+  data.tar.gz: 5584f49e2c7e848ef93fdb5bf6cb1270fa3154f77beee255eb64e221aab20ce8e4828b4b8381c5268e1503b1b0967d4fab81811be718f23f247951ccdf1c142a

data/CHANGELOG.md

@@ -3,6 +3,99 @@
 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.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 is not
+explained by this and remains open.
+
+## 0.12.0
+
+Nothing a page must provide changes in this release: no new attribute, no
+change to how the widget finds anything a page declares. A host moving a CDN
+pin from `@0.11` to `@0.12` has nothing to edit.
+
+
+### Fixed: the panel can be read while a turn is still running
+
+Adding content mid-turn always scrolled the panel back to the end — a tool
+chip, a thinking block, or any delta. On a short answer nobody notices. On a
+long tool-using turn the deltas keep coming for minutes, so scrolling back
+through the answer was impossible by any means: wheel, trackpad and keyboard
+all appeared dead, because each attempt was undone within milliseconds.
+
+The panel now follows the output only while the reader is at the end of it.
+Scroll away and it leaves you alone; come back to the end and it resumes.
+Asking a new question always returns you to the end, and a conversation
+restored after a page load still opens at its end.
+
+### Fixed: a wide table is readable instead of one letter per column
+
+A markdown table was itself the scrolling box (`display: block;
+overflow-x: auto`), so it was capped at the bubble width, squeezed its columns,
+and `word-wrap: break-word` then broke every word one character per line. A
+six-column table of genomic notation became a column of single letters. Tables
+now sit in a wrapper that scrolls sideways while the table keeps its natural
+width: the same answer went from 3,155px to 1,426px of message height in
+Chromium, and the columns are readable.
+
+
+### Added: a turn is sized against the model's real context window
+
+The widget now reads each model's context window from the hub (`/api/llms`
+reports `max_input_tokens`) and uses it for two decisions it used to make from
+fixed guesses.
+
+**Old tool results are given up rather than letting the round be refused.**
+When the next round would not fit, the oldest tool results are replaced — one
+at a time, stopping as soon as the round fits — with a short note saying the
+result was dropped and may be fetched again. Nothing else is touched: not the
+system prompt, not the questions, and not what the assistant said about those
+results, so the model keeps its own summary of what it read. The panel says
+which tool's result went, so a thinner context is visible rather than silent.
+
+A tool message is replaced, never removed, because a provider rejects a
+`tool_call` that has no matching result.
+
+The declared tools are counted too, not only the messages. Their names,
+descriptions and schemas are part of every request — around twenty tools is a
+few thousand tokens before the conversation starts — so a budget that counted
+messages alone would evict too late to help.
+
+**The reference-resource budget scales with the window.** It was a fixed 8 KB
+whatever the model. It is now about 6% of the window — the same share 8 KB was
+of the 32,000-token model it was chosen for — so a 128,000-token model may
+attach about 32 KB, up to a 64 KB cap. A model whose window the hub does not
+report keeps the old 8 KB.
+
+Nothing changes for a host that does not want this: there is no new attribute,
+and a hub that does not report a window makes the widget behave exactly as
+before. It is a release of llm_meta_server, not the widget, that turns the
+behaviour on.
+
 ## 0.11.1
 
 ### Fixed: a page action that navigates no longer loses the turn

data/README.md

@@ -61,7 +61,7 @@ Option 3 if it does not.
 
 ```ruby
 # Gemfile
-gem "llm_meta_widget", "~> 0.11.1"
+gem "llm_meta_widget", "~> 0.12.1"
 ```
 
 ```bash
@@ -152,17 +152,17 @@ 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.11"></script>
+<script type="module" src="https://cdn.jsdelivr.net/npm/@aibranch/llm-meta-widget@0.12"></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.11` is a version range, and it stops at 0.11.x on purpose.** You receive
+**`@0.12` is a version range, and it stops at 0.12.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.12 is therefore a change you make yourself. Read
+Moving to 0.13 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
@@ -698,8 +698,12 @@ the model's context. The widget reads two optional fields the
   `_meta`; the widget still reads that when `size` is absent, but it will be
   removed, so emit `size`.
   The widget decides whether it can afford the resource *before* fetching it. If
-  the resource is over its budget of 8 KB, the bytes never cross the wire, and
-  the LLM asks for what it needs through your tools instead.
+  the resource is over that budget, the bytes never cross the wire, and the LLM
+  asks for what it needs through your tools instead.
+  The budget is a share of the model's own context window, which the widget
+  reads from the hub: about 8 KB for a 32,000-token model, about 32 KB for a
+  128,000-token one, and at most 64 KB. When the hub does not report a window,
+  the budget is 8 KB.
 - **`volatility`** — `"stable"` (read once, re-used) or `"volatile"` (re-read
   on every turn that uses it).
 - **`autoAttach`** — may the widget put this in the model's context without

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

@@ -26,7 +26,8 @@ import { runChatLoop, fetchMcpManifest, listMcpPrompts, getMcpPrompt,
          readStaticPrimitivesCard, getPagePrompt,
          planPageResources, pageResourceLinesForTurn,
          promptArgState, mergeStaticPrimitivesCards,
-         PAGE_CARD_MEDIA_TYPE, pageHandlers } from "./orchestrator.js";
+         PAGE_CARD_MEDIA_TYPE, pageHandlers,
+         modelWindowFrom, resourceBudgetBytes } from "./orchestrator.js";
 import { marked } from "./marked.esm.js";
 import { readConfig } from "./config.js";
 import conversationCss from "../../stylesheets/llm_meta_widget/conversation.css";
@@ -154,6 +155,24 @@ function boot(cfg) {
   	var root         = document.getElementById("llm-meta-widget-chat");
   	var toggleBtn    = document.getElementById("llm-meta-widget-toggle");
   	var historyEl    = root.querySelector(".lmw-messages");
+
+  	// Following the output, or reading back through it?
+  	//
+  	// Every mid-turn pin used to be unconditional: a tool chip, a thinking
+  	// block, or any delta slammed the view back to the end. On a short answer
+  	// nobody notices. On a long tool turn the deltas keep coming for minutes,
+  	// and the reader cannot scroll anywhere by any means — wheel, trackpad,
+  	// keyboard — because each attempt is undone within milliseconds. Reported
+  	// from TogoMCP and reproduced on PubDictionaries (2026-10-16).
+  	//
+  	// 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"
+
+  	function atBottom() {
+  		return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
+  	}
+  	function pinToBottom() { historyEl.scrollTop = historyEl.scrollHeight; }
   	var formEl       = root.querySelector(".lmw-form");
   	var inputEl      = root.querySelector(".lmw-input");
   	var clearBtn     = root.querySelector(".lmw-clear");
@@ -379,8 +398,6 @@ function boot(cfg) {
   	}
 
   	function refreshRemoteToolsFromPicker() {
-  		// Flatten every SELECTED tool (across all servers) into remoteTools,
-  		// adapted to runChatLoop's expected { id, name, description, input_schema }.
   		var flat = [];
   		var seen = {};
   		hubMcpServers.forEach(function(s) {
@@ -456,6 +473,10 @@ function boot(cfg) {
   					//   - Ollama:                   `available_models: [{ value, label, ... }]`
   					// Anon widget uses api_key_uuid = "ollama-local" so only Ollama models
   					// are invocable; filter to that family and use its subshape.
+  					// Learned from every family, not only the one the picker lists: the
+  					// configured model is often hosted while the picker shows local ones.
+  					llmsPayload = payload;
+  					modelWindow = modelWindowFrom(payload, MODEL);
   					var flat = [];
   					(payload.llms || []).forEach(function(llm) {
   						if (llm.family !== "ollama") return;
@@ -601,7 +622,12 @@ function boot(cfg) {
   	}
 
   	if (modelPicker) {
-  		modelPicker.addEventListener("change", function() { MODEL = modelPicker.value; });
+  		modelPicker.addEventListener("change", function() {
+  			MODEL = modelPicker.value;
+  			// The window belongs to the model, not to the session: a switch has to
+  			// move it, or every budget below is sized for the model left behind.
+  			modelWindow = modelWindowFrom(llmsPayload, MODEL);
+  		});
   	}
 
   	// Close the tools dropdown on any click outside its area. Native
@@ -634,25 +660,52 @@ function boot(cfg) {
   	var hostWidePrompts = pageCard.prompts.map(function(p) {
   		return Object.assign({}, p, { source: "page" });
   	});
+  	// How much room the selected model has, from /api/llms. null until that
+  	// call answers, and null forever if the hub is older than the field — in
+  	// which case the loop budgets nothing, exactly as it always did.
+  	var modelWindow = null;
+  	// The /api/llms answer, kept so switching model in the picker can resolve
+  	// that model's window. Without it a visitor who switches from a 262k model
+  	// to a 32k one keeps the big window — no eviction, and a resource budget
+  	// far larger than the small model can hold.
+  	var llmsPayload = null;
   	var resourceContext = null;   // payload of the host's reference resource
   	var resourcePlan = null;      // the pre-flight decision, kept so Clear can re-arm the gate
 
   	// Beyond ~2k tokens a reference resource starts crowding out the
   	// conversation on a 32k-context local model — production PubDictionaries
-  	// is 218 dictionaries / ~35KB / ~10k tokens.
-  	var RESOURCE_BUDGET_BYTES = 8000;
-
-  	// The page's own resources, planned once from the card. Unlike the hub's
-  	// single reference resource these are a list: a page declares one per
-  	// thing it knows, each with its own description.
-  	var pageResourcePlans = planPageResources({
-  		entries:     pageCard.resources,
-  		budgetBytes: RESOURCE_BUDGET_BYTES,
-  		onSkip: function(plan) {
-  			console.info("[llm_meta_widget] not attaching " + plan.uri +
-  			             " (" + plan.reason + ", size=" + plan.size + ")");
+  	// is 218 dictionaries / ~35KB / ~10k tokens. That share of the window is
+  	// what scales now the window is known: 8000 remains the 32k case, and the
+  	// floor for a model whose window the hub does not report.
+  	function resourceBudget() { return resourceBudgetBytes(modelWindow); }
+
+  	// The page's own resources, planned from the card — but NOT here. Unlike
+  	// the hub's single reference resource these are a list: a page declares one
+  	// per thing it knows, each with its own description.
+  	//
+  	// Planning them at this point would pin every one of them to the floor
+  	// budget: the budget follows the model's window, which arrives with
+  	// /api/llms a moment after this runs. The budget was derived and then
+  	// never used, so a 128k model could attach nothing a 32k one could not.
+  	// Re-planned whenever the budget changes, which is at most once per model
+  	// switch.
+  	var pageResourcePlans = null;
+  	var pageResourcePlansBudget = null;
+  	function pageResourcePlansNow() {
+  		var budget = resourceBudget();
+  		if (pageResourcePlans === null || budget !== pageResourcePlansBudget) {
+  			pageResourcePlansBudget = budget;
+  			pageResourcePlans = planPageResources({
+  				entries:     pageCard.resources,
+  				budgetBytes: budget,
+  				onSkip: function(plan) {
+  					console.info("[llm_meta_widget] not attaching " + plan.uri +
+  					             " (" + plan.reason + ", size=" + plan.size + ")");
+  				}
+  			});
   		}
-  	});
+  		return pageResourcePlans;
+  	}
   	var pageResourceCache = {};
 
 
@@ -694,7 +747,7 @@ function boot(cfg) {
   				// the bug this shape prevents.
   				var loaded = await loadHostResource({
   					endpoint:    endpoint,
-  					budgetBytes: RESOURCE_BUDGET_BYTES,
+  					budgetBytes: resourceBudget(),
   					list:        listMcpResources,
   					read:        readMcpResource,
   					onSkip: function(plan) {
@@ -772,7 +825,9 @@ function boot(cfg) {
   			});
   			if (body.parentNode) body.parentNode.appendChild(row);
   		});
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		// Unconditional: a restored conversation opens at its end, which is where
+  		// the reader left off. Nothing is streaming yet, so nobody is being yanked.
+  		pinToBottom();
   		return true;
   	}
 
@@ -876,6 +931,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>
@@ -914,7 +971,9 @@ function boot(cfg) {
   		div.appendChild(document.createTextNode(" "));
   		div.appendChild(body);
   		historyEl.appendChild(div);
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		// 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;
   	}
@@ -926,6 +985,31 @@ function boot(cfg) {
   	function renderMarkdownInto(el, mdText) {
   		try { el.innerHTML = marked.parse(mdText); }
   		catch (e) { el.textContent = mdText; }  // fall back to raw on parse error
+  		wrapTablesForScrolling(el);
+  	}
+
+  	// A markdown table gets its own horizontal scroller.
+  	//
+  	// `display: block; overflow-x: auto; max-width: 100%` on the table alone
+  	// does NOT do this: the box is capped at the bubble width, so the table
+  	// re-lays out to fit and squeezes its columns, and `word-wrap: break-word`
+  	// from .message then breaks every word one character per line. A six-column
+  	// table of genomic notation became a column of single letters thousands of
+  	// pixels tall (seen on PubDictionaries, 2026-10-16).
+  	//
+  	// The table has to sit INSIDE a capped box and keep its own natural width,
+  	// which is what a wrapper gives it.
+  	function wrapTablesForScrolling(el) {
+  		var tables = el.querySelectorAll("table");
+  		for (var i = 0; i < tables.length; i++) {
+  			var table = tables[i];
+  			// No already-wrapped guard: renderMarkdownInto replaces the whole
+  			// innerHTML first, so every table reaching here is freshly parsed.
+  			var wrap = document.createElement("div");
+  			wrap.className = "lmw-table-scroll";
+  			table.parentNode.insertBefore(wrap, table);
+  			wrap.appendChild(table);
+  		}
   	}
 
   	// Role labels mirror llm_meta_chat's chats/_message.html.erb:
@@ -977,6 +1061,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");
@@ -985,7 +1071,7 @@ function boot(cfg) {
   		chip.dataset.tool = toolCall.name;
   		row.appendChild(chip);
   		pendingChips.push(chip);
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		if (following) pinToBottom();
   	}
 
   	function resolveToolCall(outcome) {
@@ -1007,6 +1093,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.
@@ -1033,7 +1121,7 @@ function boot(cfg) {
   		} else {
   			historyEl.appendChild(details);
   		}
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		if (following) pinToBottom();
   		currentThinkingBlock = details;
   		currentThinkingBody  = body;
   		return body;
@@ -1137,7 +1225,7 @@ function boot(cfg) {
   			cached:      resourceContext,
   			endpoint:    resourcePlan && resourcePlan.endpoint,
   			read:        readMcpResource,
-  			budgetBytes: RESOURCE_BUDGET_BYTES
+  			budgetBytes: resourceBudget()
   		});
   		resourceContext = turn.cached;
 
@@ -1145,9 +1233,9 @@ function boot(cfg) {
   		// Volatile ones are re-read here, which is the whole point: a form field
   		// read at boot is already stale by the time anyone sends a message.
   		var page = await pageResourceLinesForTurn({
-  			plans:       pageResourcePlans,
+  			plans:       pageResourcePlansNow(),
   			resources:   handlers.resources,
-  			budgetBytes: RESOURCE_BUDGET_BYTES,
+  			budgetBytes: resourceBudget(),
   			cache:       pageResourceCache
   		});
   		pageResourceCache = page.cache;
@@ -1226,8 +1314,16 @@ function boot(cfg) {
   				hostWideTools: hostWideTools,
   				aiActions:     handlers.tools,
   				maxRounds:     MAX_ROUNDS,
+  				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.");
+  				},
   				onToolCall: function(toolCall) {
   					announceToolCall(toolCall);
   					// At once, not throttled: this call may be the one that navigates, and
@@ -1261,19 +1357,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;
-  					historyEl.scrollTop = historyEl.scrollHeight;
+  					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();
-  					historyEl.scrollTop = historyEl.scrollHeight;
+  					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

@@ -168,6 +168,16 @@ async function runChatLoop(opts) {
     remoteTools = [],
     hostWideTools = [],
     maxRounds = 10,
+    // The model's own context window, from /api/llms. Without it the loop
+    // cannot know how much room is left, so it budgets nothing and a long
+    // tool-heavy turn is refused by the provider instead of degrading.
+    contextWindow = null,
+    // Tokens held back for the answer: a request that fills the window leaves
+    // nothing to generate into.
+    outputReserve = 2048,
+    // Called when a tool result is dropped to make room, so the panel can say
+    // so rather than the context quietly thinning.
+    onContextEvicted,
     // "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.
@@ -189,7 +199,7 @@ async function runChatLoop(opts) {
     onPhase,
     ...singleOpts
   } = opts;
-  const messages = [...singleOpts.messages || []];
+  let messages = [...singleOpts.messages || []];
   const remoteByName = Object.fromEntries((remoteTools || []).map((t) => [t.name, t]));
   const hostWideByName = Object.fromEntries((hostWideTools || []).map((t) => [t.name, t]));
   const toolIds = [...singleOpts.toolIds || [], ...(remoteTools || []).map((t) => t.id)];
@@ -200,6 +210,12 @@ async function runChatLoop(opts) {
   }
   const mergedLocalTools = Object.values(inlineByName);
   const rounds = [];
+  const evicted = [];
+  const toolsTokens = estimateToolsTokens([].concat(
+    singleOpts.localTools || [],
+    remoteTools || [],
+    hostWideTools || []
+  ));
   const allDispatched = [];
   const allSkipped = [];
   let lastResult = null;
@@ -230,6 +246,17 @@ async function runChatLoop(opts) {
   for (let round = 0; round < maxRounds; round++) {
     if (signal?.aborted) throw new DOMException("aborted", "AbortError");
     onRoundStart?.(round);
+    const room = evictOldToolResults({
+      messages,
+      window: contextWindow,
+      dropped: evicted,
+      // The tools take their share of the window before any message does.
+      reserve: outputReserve + toolsTokens
+    });
+    if (room.messages !== messages) {
+      messages = room.messages;
+      onContextEvicted?.(evicted.slice());
+    }
     const call = provider === "ollama" ? ollamaChatCall : singleLlmCall;
     const turnResult = await call({
       ...singleOpts,
@@ -561,6 +588,70 @@ 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 * RESOURCE_BYTES_PER_TOKEN);
+  return Math.min(cap, Math.max(floor, share));
+}
+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 + estimateTextTokens(content) + MESSAGE_OVERHEAD_TOKENS;
+  }, 0);
+}
+function estimateToolsTokens(tools) {
+  const text = (tools || []).map((t) => JSON.stringify({
+    name: t?.name,
+    description: t?.description,
+    schema: t?.input_schema || t?.inputSchema
+  })).join("");
+  return estimateTextTokens(text);
+}
+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 out = messages.slice();
+  for (let i = 0; i < out.length; i++) {
+    if (estimateTokens(out) <= budget) break;
+    const m = out[i];
+    if (m?.role !== "tool") continue;
+    if (typeof m.content === "string" && m.content.startsWith("[dropped")) continue;
+    dropped.push({ name: m.name, tokens: estimateTokens([m]) });
+    out[i] = Object.assign({}, m, {
+      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 };
+}
+function modelWindowFrom(payload, modelId) {
+  for (const family of payload && payload.llms || []) {
+    const entries = [].concat(family.available_models || [], family.models || []);
+    for (const entry of entries) {
+      if (!entry) continue;
+      const id = entry.value || entry.name;
+      if (id !== modelId) continue;
+      const window2 = Number(entry.max_input_tokens);
+      return Number.isFinite(window2) && window2 > 0 ? window2 : null;
+    }
+  }
+  return null;
+}
 var PAGE_GLOBAL_TRANSPORT = "page-global";
 function declaredPageGlobal(card) {
   for (const remote of card && card.remotes || []) {
@@ -3237,12 +3328,28 @@ var conversation_default = `/*
 	white-space: pre;
 }
 .llm-meta-conversation .message-content pre code { background: none; padding: 0; }
+/* The scroller is the WRAPPER, not the table: a table that is itself the
+ * scrolling box gets capped at the bubble width and squeezes its columns
+ * instead of overflowing, and .message's word-wrap then breaks every word
+ * one character per line. The wrapper is capped; the table inside keeps its
+ * natural width and scrolls sideways. */
+.llm-meta-conversation .message-content .lmw-table-scroll {
+	overflow-x: auto;
+	margin: 0.5em 0;
+}
 .llm-meta-conversation .message-content table {
 	border-collapse: collapse;
-	margin: 0.5em 0;
-	display: block;
-	overflow-x: auto;
-	max-width: 100%;
+	/* min-width so a narrow table still fills the bubble, width:max-content so
+	 * a wide one is laid out at its natural size and the wrapper scrolls. */
+	width: max-content;
+	min-width: 100%;
+}
+/* Inside a table, breaking mid-token is what produced the one-letter columns;
+ * cells keep their words whole and the wrapper scrolls instead. */
+.llm-meta-conversation .message-content th,
+.llm-meta-conversation .message-content td {
+	word-wrap: normal;
+	overflow-wrap: normal;
 }
 .llm-meta-conversation .message-content th,
 .llm-meta-conversation .message-content td {
@@ -3844,6 +3951,13 @@ function boot(cfg) {
   var root = document.getElementById("llm-meta-widget-chat");
   var toggleBtn = document.getElementById("llm-meta-widget-toggle");
   var historyEl = root.querySelector(".lmw-messages");
+  var SCROLL_PIN_SLACK = 40;
+  function atBottom() {
+    return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
+  }
+  function pinToBottom() {
+    historyEl.scrollTop = historyEl.scrollHeight;
+  }
   var formEl = root.querySelector(".lmw-form");
   var inputEl = root.querySelector(".lmw-input");
   var clearBtn = root.querySelector(".lmw-clear");
@@ -4069,6 +4183,8 @@ function boot(cfg) {
       tasks.push(fetch(LLM_BASE + "/api/llms", { headers: { "Accept": "application/json" } }).then(function(r) {
         return r.ok ? r.json() : { llms: [] };
       }).then(function(payload) {
+        llmsPayload = payload;
+        modelWindow = modelWindowFrom(payload, MODEL);
         var flat = [];
         (payload.llms || []).forEach(function(llm) {
           if (llm.family !== "ollama") return;
@@ -4189,6 +4305,7 @@ function boot(cfg) {
   if (modelPicker) {
     modelPicker.addEventListener("change", function() {
       MODEL = modelPicker.value;
+      modelWindow = modelWindowFrom(llmsPayload, MODEL);
     });
   }
   if (toolsPicker) {
@@ -4213,16 +4330,29 @@ function boot(cfg) {
   var hostWidePrompts = pageCard.prompts.map(function(p) {
     return Object.assign({}, p, { source: "page" });
   });
+  var modelWindow = null;
+  var llmsPayload = null;
   var resourceContext = null;
   var resourcePlan = null;
-  var RESOURCE_BUDGET_BYTES = 8e3;
-  var pageResourcePlans = planPageResources({
-    entries: pageCard.resources,
-    budgetBytes: RESOURCE_BUDGET_BYTES,
-    onSkip: function(plan) {
-      console.info("[llm_meta_widget] not attaching " + plan.uri + " (" + plan.reason + ", size=" + plan.size + ")");
+  function resourceBudget() {
+    return resourceBudgetBytes(modelWindow);
+  }
+  var pageResourcePlans = null;
+  var pageResourcePlansBudget = null;
+  function pageResourcePlansNow() {
+    var budget = resourceBudget();
+    if (pageResourcePlans === null || budget !== pageResourcePlansBudget) {
+      pageResourcePlansBudget = budget;
+      pageResourcePlans = planPageResources({
+        entries: pageCard.resources,
+        budgetBytes: budget,
+        onSkip: function(plan) {
+          console.info("[llm_meta_widget] not attaching " + plan.uri + " (" + plan.reason + ", size=" + plan.size + ")");
+        }
+      });
     }
-  });
+    return pageResourcePlans;
+  }
   var pageResourceCache = {};
   restoreConversation();
   var promptsEl = root.querySelector(".lmw-prompts");
@@ -4243,7 +4373,7 @@ function boot(cfg) {
       if (resourcePlan === null) {
         var loaded = await loadHostResource({
           endpoint,
-          budgetBytes: RESOURCE_BUDGET_BYTES,
+          budgetBytes: resourceBudget(),
           list: listMcpResources,
           read: readMcpResource,
           onSkip: function(plan) {
@@ -4305,7 +4435,7 @@ function boot(cfg) {
       });
       if (body.parentNode) body.parentNode.appendChild(row);
     });
-    historyEl.scrollTop = historyEl.scrollHeight;
+    pinToBottom();
     return true;
   }
   function renderWelcome() {
@@ -4380,6 +4510,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");
@@ -4406,7 +4537,7 @@ function boot(cfg) {
     div.appendChild(document.createTextNode(" "));
     div.appendChild(body);
     historyEl.appendChild(div);
-    historyEl.scrollTop = historyEl.scrollHeight;
+    if (role === "user" || following) pinToBottom();
     body.roleLabel = label;
     return body;
   }
@@ -4416,6 +4547,17 @@ function boot(cfg) {
     } catch (e) {
       el.textContent = mdText;
     }
+    wrapTablesForScrolling(el);
+  }
+  function wrapTablesForScrolling(el) {
+    var tables = el.querySelectorAll("table");
+    for (var i = 0; i < tables.length; i++) {
+      var table = tables[i];
+      var wrap = document.createElement("div");
+      wrap.className = "lmw-table-scroll";
+      table.parentNode.insertBefore(wrap, table);
+      wrap.appendChild(table);
+    }
   }
   function roleLabel(role) {
     if (role === "user") return "\u{1F464} You";
@@ -4445,6 +4587,7 @@ function boot(cfg) {
     return liveChips;
   }
   function announceToolCall(toolCall) {
+    var following = atBottom();
     var row = chipRow();
     if (!row) return;
     var chip = document.createElement("span");
@@ -4453,7 +4596,7 @@ function boot(cfg) {
     chip.dataset.tool = toolCall.name;
     row.appendChild(chip);
     pendingChips.push(chip);
-    historyEl.scrollTop = historyEl.scrollHeight;
+    if (following) pinToBottom();
   }
   function resolveToolCall(outcome) {
     var idx = pendingChips.findIndex(function(c) {
@@ -4469,6 +4612,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";
@@ -4493,7 +4637,7 @@ function boot(cfg) {
     } else {
       historyEl.appendChild(details);
     }
-    historyEl.scrollTop = historyEl.scrollHeight;
+    if (following) pinToBottom();
     currentThinkingBlock = details;
     currentThinkingBody = body;
     return body;
@@ -4573,13 +4717,13 @@ function boot(cfg) {
       cached: resourceContext,
       endpoint: resourcePlan && resourcePlan.endpoint,
       read: readMcpResource,
-      budgetBytes: RESOURCE_BUDGET_BYTES
+      budgetBytes: resourceBudget()
     });
     resourceContext = turn.cached;
     var page = await pageResourceLinesForTurn({
-      plans: pageResourcePlans,
+      plans: pageResourcePlansNow(),
       resources: handlers.resources,
-      budgetBytes: RESOURCE_BUDGET_BYTES,
+      budgetBytes: resourceBudget(),
       cache: pageResourceCache
     });
     pageResourceCache = page.cache;
@@ -4646,8 +4790,14 @@ function boot(cfg) {
         hostWideTools,
         aiActions: handlers.tools,
         maxRounds: MAX_ROUNDS,
+        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.");
+        },
         onToolCall: function(toolCall) {
           announceToolCall(toolCall);
           persistConversation();
@@ -4666,19 +4816,21 @@ function boot(cfg) {
           collapseThinkingBlock();
         },
         onThinkingDelta: function(delta) {
+          var following = atBottom();
           var body = ensureThinkingBlock();
           body.appendChild(document.createTextNode(delta));
           body.scrollTop = body.scrollHeight;
-          historyEl.scrollTop = historyEl.scrollHeight;
+          if (following) pinToBottom();
         },
         onTextDelta: function(delta) {
+          var following = atBottom();
           markDone(assistantBody.roleLabel);
           collapseThinkingBlock();
           assistantMarkdown += delta;
           renderMarkdownInto(assistantBody, assistantMarkdown);
           liveTurn.content = assistantMarkdown;
           persistSoon();
-          historyEl.scrollTop = historyEl.scrollHeight;
+          if (following) pinToBottom();
         }
       });
       liveTurn.content = result.content;

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

@@ -325,6 +325,16 @@ export async function runChatLoop(opts) {
     remoteTools = [],
     hostWideTools = [],
     maxRounds = 10,
+    // The model's own context window, from /api/llms. Without it the loop
+    // cannot know how much room is left, so it budgets nothing and a long
+    // tool-heavy turn is refused by the provider instead of degrading.
+    contextWindow = null,
+    // Tokens held back for the answer: a request that fills the window leaves
+    // nothing to generate into.
+    outputReserve = 2048,
+    // Called when a tool result is dropped to make room, so the panel can say
+    // so rather than the context quietly thinning.
+    onContextEvicted,
     // "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.
@@ -347,7 +357,7 @@ export async function runChatLoop(opts) {
     ...singleOpts
   } = opts
 
-  const messages     = [ ...(singleOpts.messages || []) ]
+  let messages       = [ ...(singleOpts.messages || []) ]
   const remoteByName = Object.fromEntries((remoteTools || []).map((t) => [ t.name, t ]))
   // Class 2: host-wide MCP tools (well-known). Map name→{endpoint, ...} for
   // dispatch. If the same name appears in aiActions, Class 3 wins there
@@ -366,6 +376,10 @@ export async function runChatLoop(opts) {
   const mergedLocalTools = Object.values(inlineByName)
 
   const rounds = []
+  const evicted = []
+  // Fixed for the turn: the declared tool set does not change between rounds.
+  const toolsTokens = estimateToolsTokens([].concat(
+  	singleOpts.localTools || [], remoteTools || [], hostWideTools || []))
   const allDispatched = []
   const allSkipped = []
   let lastResult = null
@@ -408,6 +422,18 @@ export async function runChatLoop(opts) {
     onRoundStart?.(round)
 
     // The loop is the same whoever answers; only the call differs.
+    // Make room before sending, rather than after being refused. Only old
+    // tool results are given up; see evictOldToolResults.
+    const room = evictOldToolResults({
+    	messages, window: contextWindow, dropped: evicted,
+    	// The tools take their share of the window before any message does.
+    	reserve: outputReserve + toolsTokens
+    });
+    if (room.messages !== messages) {
+    	messages = room.messages;
+    	onContextEvicted?.(evicted.slice());
+    }
+
     const call = provider === "ollama" ? ollamaChatCall : singleLlmCall
     const turnResult = await call({
       ...singleOpts,
@@ -891,6 +917,142 @@ export const PAGE_CARD_MEDIA_TYPE = "application/mcp-static-primitives+json"
 // card, find the handlers and dispatch. The three legacy globals
 // (aiActions/aiPrompts/aiResources) are names only this widget knows, and are
 // configurable per page, so nothing outside could rely on them.
+// How much room a model has, read from /api/llms — the one call the widget
+// already makes before a turn. Scans every family, because the picker shows
+// only the local ones while the configured model is often hosted, and the two
+// families use different shapes for the same thing (`value` vs `name`).
+//
+// Returns null when the hub does not say. Null means "no budget to work with",
+// which is not the same as zero, and every caller below treats it as "do not
+// guess" rather than "no room".
+// How many bytes of reference resources a turn may attach, derived from the
+// model's window instead of guessed. The old fixed 8000 was chosen as "~2k
+// tokens, beyond which a resource crowds out the conversation on a 32k local
+// model" — which is 6.25% of that window, so the same share reproduces 8000 at
+// 32k exactly and gives a 128k model the 32 KB it can afford.
+//
+// The floor keeps the previous behaviour whenever the window is unknown. The
+// cap is there because these bytes are fetched and inlined on every turn: the
+// largest real catalog (PubDictionaries, 218 dictionaries) is ~35 KB, so 64 KB
+// 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 * RESOURCE_BYTES_PER_TOKEN)
+  return Math.min(cap, Math.max(floor, share))
+}
+
+// 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 + estimateTextTokens(content) + MESSAGE_OVERHEAD_TOKENS
+  }, 0)
+}
+
+// What the declared tools cost in the window. They are part of every request:
+// names, descriptions and JSON schemas. On the hub path the browser sends only
+// `tool_ids` and the hub expands the schemas, but the browser listed those
+// tools to build its picker, so it still has what it needs to price them.
+//
+// This is not a detail. TogoMCP declares around twenty tools, which is a few
+// thousand tokens standing in the window before the conversation starts; a
+// budget counting only messages runs low and evicts too late to help.
+export function estimateToolsTokens(tools) {
+  const text = (tools || []).map((t) => JSON.stringify({
+    name: t?.name, description: t?.description, schema: t?.input_schema || t?.inputSchema
+  })).join("")
+  // Counted with the same classes: a schema is JSON, which is the dense case.
+  return estimateTextTokens(text)
+}
+
+// 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
+// summary survives. Nothing else is touched — not the system prompt, not the
+// questions, not the assistant's words.
+//
+// Each dropped result leaves a marker in its place, because a tool message must
+// still answer its tool_call_id: a provider that sees a call with no result
+// rejects the request, and a model that sees no mention of the result would
+// happily call the same tool again.
+//
+// Returns the messages unchanged when the window is unknown. Guessing a window
+// would be worse than not budgeting: too low throws away context the turn
+// needed, and too high fails at the provider anyway.
+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 }
+
+  const out = messages.slice()
+  for (let i = 0; i < out.length; i++) {
+    if (estimateTokens(out) <= budget) break
+    const m = out[i]
+    if (m?.role !== "tool") continue
+    if (typeof m.content === "string" && m.content.startsWith("[dropped")) continue
+
+    dropped.push({ name: m.name, tokens: estimateTokens([ m ]) })
+    out[i] = Object.assign({}, m, {
+      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 }
+}
+
+export function modelWindowFrom(payload, modelId) {
+  for (const family of (payload && payload.llms) || []) {
+    const entries = [].concat(family.available_models || [], family.models || [])
+    for (const entry of entries) {
+      if (!entry) continue
+      const id = entry.value || entry.name
+      if (id !== modelId) continue
+      const window = Number(entry.max_input_tokens)
+      return Number.isFinite(window) && window > 0 ? window : null
+    }
+  }
+  return null
+}
+
 export const PAGE_GLOBAL_TRANSPORT = "page-global"
 
 export function declaredPageGlobal(card) {

data/app/assets/stylesheets/llm_meta_widget/conversation.css

@@ -109,12 +109,28 @@
 	white-space: pre;
 }
 .llm-meta-conversation .message-content pre code { background: none; padding: 0; }
+/* The scroller is the WRAPPER, not the table: a table that is itself the
+ * scrolling box gets capped at the bubble width and squeezes its columns
+ * instead of overflowing, and .message's word-wrap then breaks every word
+ * one character per line. The wrapper is capped; the table inside keeps its
+ * natural width and scrolls sideways. */
+.llm-meta-conversation .message-content .lmw-table-scroll {
+	overflow-x: auto;
+	margin: 0.5em 0;
+}
 .llm-meta-conversation .message-content table {
 	border-collapse: collapse;
-	margin: 0.5em 0;
-	display: block;
-	overflow-x: auto;
-	max-width: 100%;
+	/* min-width so a narrow table still fills the bubble, width:max-content so
+	 * a wide one is laid out at its natural size and the wrapper scrolls. */
+	width: max-content;
+	min-width: 100%;
+}
+/* Inside a table, breaking mid-token is what produced the one-letter columns;
+ * cells keep their words whole and the wrapper scrolls instead. */
+.llm-meta-conversation .message-content th,
+.llm-meta-conversation .message-content td {
+	word-wrap: normal;
+	overflow-wrap: normal;
 }
 .llm-meta-conversation .message-content th,
 .llm-meta-conversation .message-content td {

data/lib/llm_meta_widget/version.rb

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

metadata

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