llm_meta_widget 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e975d248dfe98bfeb8af1a17aeec7aa411f38b6b60a6563a52894faf70efed5b
-  data.tar.gz: a23323a6012fbc7ce3effb0527026a42d1ae0e6c2f2b57e0049bd53a0cc6625d
+  metadata.gz: b2ba425d2cce6f582baf43df6ca5512bd344ccd78f1e74b56887eb6f3ccdaff6
+  data.tar.gz: a0127db4a9a59f6a88c052e9f6d54d1d0664c168c4de6cd16fe480fa95a73327
 SHA512:
-  metadata.gz: 98014e701daaddb224748b7eb130b3092f8cf6653a05c9fb1f7cd5b63cdd17985ec8f65ce647f4cd1800c6b4f191ac9e5a35fb4229b7237673acdf6317222114
-  data.tar.gz: 183fb69e15ec08f3cc4724ba467ff6da5078579c39c85c2a349b5333c30b57e6196a1a45e43514fddfd05903752a02d35ac99d703f3b40bf2584c18aa4ab9714
+  metadata.gz: 7b3d3ddd173ef207ccd651ef5a455ffbdc2941fd0d00bc9e1bce687d824cf789b14b8e0d09f898fbfc0db132d4e384cdb7637289467c3259d180f7e71fdd1c16
+  data.tar.gz: eea0ceefa6b8cecc7472d754c16d0de51a04ad92afb69dfe237c31c1448873761d7a1c7fa90c317fc9b29c568c4c2eecf7fe3f7dead0b467e1e9d68b93dafd57

data/CHANGELOG.md

@@ -3,6 +3,89 @@
 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.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
+
+The transcript was saved once, after the chat loop finished. A page action that
+navigates — submitting a form, following a link — unloads the page while the
+loop is still running, so that turn was never saved: not the question, not
+whatever the assistant had already said, and not the record of which tools ran.
+After the navigation the panel came back with the previous turns and nothing of
+the one that had just happened.
+
+The turn is now saved as it happens. The question is saved before the model is
+called, streamed text is saved as it arrives, and a save always happens
+immediately before a tool call runs, because that call may be the one that
+navigates.
+
+This matters to any page that declares an action which navigates. Nothing to
+change in your page.
+
 ## 0.11.0
 
 ### Added: a page can say where its handlers live

data/README.md

@@ -61,7 +61,7 @@ Option 3 if it does not.
 
 ```ruby
 # Gemfile
-gem "llm_meta_widget", "~> 0.11.0"
+gem "llm_meta_widget", "~> 0.12.0"
 ```
 
 ```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,28 @@ 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"
+  	var followingOutput  = true;
+
+  	function atBottom() {
+  		return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
+  	}
+  	function pinToBottom() { historyEl.scrollTop = historyEl.scrollHeight; }
+  	// Called wherever content is added mid-turn.
+  	function pinIfFollowing() { if (followingOutput) pinToBottom(); }
+  	historyEl.addEventListener("scroll", function() { followingOutput = atBottom(); });
   	var formEl       = root.querySelector(".lmw-form");
   	var inputEl      = root.querySelector(".lmw-input");
   	var clearBtn     = root.querySelector(".lmw-clear");
@@ -302,6 +325,17 @@ function boot(cfg) {
   			model: MODEL
   		});
   	}
+
+  	// Saving on every streamed delta would write to sessionStorage hundreds of
+  	// times for one answer, so the stream saves at most this often. The moments
+  	// that MUST save at once — the turn starting, a tool call about to run, the
+  	// turn ending — call persistConversation directly.
+  	var lastPersist = 0;
+  	function persistSoon() {
+  		if (Date.now() - lastPersist < 400) return;
+  		lastPersist = Date.now();
+  		persistConversation();
+  	}
   	// The page card is the same static-primitives envelope a server puts in
   	// its Server Card, delivered in the document. Its `tools` REPLACE the
   	// older #ai-actions schema tag rather than merging with it: two sources
@@ -368,8 +402,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) {
@@ -445,6 +477,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;
@@ -590,7 +626,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
@@ -623,25 +664,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 = {};
 
 
@@ -683,7 +751,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) {
@@ -761,7 +829,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;
   	}
 
@@ -903,7 +973,7 @@ function boot(cfg) {
   		div.appendChild(document.createTextNode(" "));
   		div.appendChild(body);
   		historyEl.appendChild(div);
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		pinIfFollowing();
   		body.roleLabel = label;   // so a turn in flight can show it is working
   		return body;
   	}
@@ -915,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:
@@ -974,7 +1069,7 @@ function boot(cfg) {
   		chip.dataset.tool = toolCall.name;
   		row.appendChild(chip);
   		pendingChips.push(chip);
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		pinIfFollowing();
   	}
 
   	function resolveToolCall(outcome) {
@@ -1022,7 +1117,7 @@ function boot(cfg) {
   		} else {
   			historyEl.appendChild(details);
   		}
-  		historyEl.scrollTop = historyEl.scrollHeight;
+  		pinIfFollowing();
   		currentThinkingBlock = details;
   		currentThinkingBody  = body;
   		return body;
@@ -1126,7 +1221,7 @@ function boot(cfg) {
   			cached:      resourceContext,
   			endpoint:    resourcePlan && resourcePlan.endpoint,
   			read:        readMcpResource,
-  			budgetBytes: RESOURCE_BUDGET_BYTES
+  			budgetBytes: resourceBudget()
   		});
   		resourceContext = turn.cached;
 
@@ -1134,9 +1229,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;
@@ -1171,6 +1266,9 @@ function boot(cfg) {
   		var userText = inputEl.value.trim();
   		if (!userText) return;
   		inputEl.value = "";
+  		// Asking something is a request to see the answer: whatever the reader was
+  		// looking at before, they are following the output again from here.
+  		followingOutput = true;
   		appendTurn("user", userText, pendingTurnLabel);
   		pendingTurnLabel = null;
 
@@ -1196,6 +1294,14 @@ function boot(cfg) {
   				.concat(conversation.map(function(t) { return { role: t.role, content: t.content }; }))
   				.concat([{ role: "user", content: userText }]);
 
+  			// Recorded before the loop runs, and saved, so a page action that
+  			// navigates cannot take the turn with it. `messages` above was already
+  			// built from the previous turns, so this does not double-send anything.
+  			conversation.push({ role: "user", content: userText });
+  			var liveTurn = { role: "assistant", content: "", tools: [] };
+  			conversation.push(liveTurn);
+  			persistConversation();
+
   			var result = await runChatLoop({
   				baseUrl:       LLM_BASE,
   				toolHubUrl:    TOOL_HUB_BASE,
@@ -1207,10 +1313,29 @@ function boot(cfg) {
   				hostWideTools: hostWideTools,
   				aiActions:     handlers.tools,
   				maxRounds:     MAX_ROUNDS,
+  				contextWindow: modelWindow,
   				provider:      LLM_PROVIDER === "ollama" ? "ollama" : "hub",
   				signal:        currentAbort.signal,
-  				onToolCall: function(toolCall) { announceToolCall(toolCall); },
-  				onToolDispatched: function(outcome) { resolveToolCall(outcome); },
+  				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
+  					// after it nothing of this turn would be saved.
+  					persistConversation();
+  				},
+  				onToolDispatched: function(outcome) {
+  					resolveToolCall(outcome);
+  					liveTurn.tools = liveTurn.tools.concat([ outcome.error
+  						? { name: outcome.toolCall.name, error: true }
+  						: { name: outcome.toolCall.name } ]);
+  					persistConversation();
+  				},
   				onPhase: function(name) {
   					// 'thinking' covers the long silence before the first
   					// token; 'responding' means text is on its way.
@@ -1234,25 +1359,26 @@ function boot(cfg) {
   					var body = ensureThinkingBlock();
   					body.appendChild(document.createTextNode(delta));
   					body.scrollTop = body.scrollHeight;
-  					historyEl.scrollTop = historyEl.scrollHeight;
+  					pinIfFollowing();
   				},
   				onTextDelta: function(delta) {
   					markDone(assistantBody.roleLabel);
   					collapseThinkingBlock();
   					assistantMarkdown += delta;
   					renderMarkdownInto(assistantBody, assistantMarkdown);
-  					historyEl.scrollTop = historyEl.scrollHeight;
+  					liveTurn.content = assistantMarkdown;
+  					persistSoon();
+  					pinIfFollowing();
   				}
   			});
-  			conversation.push({ role: "user", content: userText });
-  			conversation.push({
-  				role:    "assistant",
-  				content: result.content,
-  				// Kept so a restored transcript still shows what ran — losing
-  				// that record is what made a navigating action unbearable.
-  				tools:   result.dispatched.map(function(d) {
-  					return d.error ? { name: d.toolCall.name, error: true } : { name: d.toolCall.name };
-  				})
+  			// The turn was recorded here until 0.11.1, after the loop returned — which
+  			// a page action that navigates never lets happen. Submitting a form
+  			// mid-turn therefore lost the whole turn: the question, whatever the
+  			// assistant had already said, and the record of what ran. It is recorded as
+  			// it happens now, and only finalised here.
+  			liveTurn.content = result.content;
+  			liveTurn.tools = result.dispatched.map(function(d) {
+  				return d.error ? { name: d.toolCall.name, error: true } : { name: d.toolCall.name };
   			});
   			persistConversation();
 

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,58 @@ 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;
+function resourceBudgetBytes(window2, { floor = 8e3, cap = 64e3 } = {}) {
+  if (!window2 || !Number.isFinite(window2)) return floor;
+  const share = Math.round(window2 * RESOURCE_SHARE_OF_WINDOW * CHARS_PER_TOKEN);
+  return Math.min(cap, Math.max(floor, share));
+}
+var CHARS_PER_TOKEN = 4;
+var MESSAGE_OVERHEAD_TOKENS = 4;
+function estimateTokens(messages) {
+  return (messages || []).reduce((sum, m) => {
+    const content = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content ?? "");
+    return sum + Math.ceil(content.length / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD_TOKENS;
+  }, 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 Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+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 +3316,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 +3939,20 @@ 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;
+  var followingOutput = true;
+  function atBottom() {
+    return historyEl.scrollHeight - historyEl.scrollTop - historyEl.clientHeight <= SCROLL_PIN_SLACK;
+  }
+  function pinToBottom() {
+    historyEl.scrollTop = historyEl.scrollHeight;
+  }
+  function pinIfFollowing() {
+    if (followingOutput) pinToBottom();
+  }
+  historyEl.addEventListener("scroll", function() {
+    followingOutput = atBottom();
+  });
   var formEl = root.querySelector(".lmw-form");
   var inputEl = root.querySelector(".lmw-input");
   var clearBtn = root.querySelector(".lmw-clear");
@@ -3963,6 +4072,12 @@ function boot(cfg) {
       model: MODEL
     });
   }
+  var lastPersist = 0;
+  function persistSoon() {
+    if (Date.now() - lastPersist < 400) return;
+    lastPersist = Date.now();
+    persistConversation();
+  }
   var typedCards = document.querySelectorAll('script[type="' + PAGE_CARD_MEDIA_TYPE + '"]');
   var pageCard;
   if (typedCards.length) {
@@ -4063,6 +4178,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;
@@ -4183,6 +4300,7 @@ function boot(cfg) {
   if (modelPicker) {
     modelPicker.addEventListener("change", function() {
       MODEL = modelPicker.value;
+      modelWindow = modelWindowFrom(llmsPayload, MODEL);
     });
   }
   if (toolsPicker) {
@@ -4207,16 +4325,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");
@@ -4237,7 +4368,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) {
@@ -4299,7 +4430,7 @@ function boot(cfg) {
       });
       if (body.parentNode) body.parentNode.appendChild(row);
     });
-    historyEl.scrollTop = historyEl.scrollHeight;
+    pinToBottom();
     return true;
   }
   function renderWelcome() {
@@ -4400,7 +4531,7 @@ function boot(cfg) {
     div.appendChild(document.createTextNode(" "));
     div.appendChild(body);
     historyEl.appendChild(div);
-    historyEl.scrollTop = historyEl.scrollHeight;
+    pinIfFollowing();
     body.roleLabel = label;
     return body;
   }
@@ -4410,6 +4541,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";
@@ -4447,7 +4589,7 @@ function boot(cfg) {
     chip.dataset.tool = toolCall.name;
     row.appendChild(chip);
     pendingChips.push(chip);
-    historyEl.scrollTop = historyEl.scrollHeight;
+    pinIfFollowing();
   }
   function resolveToolCall(outcome) {
     var idx = pendingChips.findIndex(function(c) {
@@ -4487,7 +4629,7 @@ function boot(cfg) {
     } else {
       historyEl.appendChild(details);
     }
-    historyEl.scrollTop = historyEl.scrollHeight;
+    pinIfFollowing();
     currentThinkingBlock = details;
     currentThinkingBody = body;
     return body;
@@ -4567,13 +4709,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;
@@ -4604,6 +4746,7 @@ function boot(cfg) {
     var userText = inputEl.value.trim();
     if (!userText) return;
     inputEl.value = "";
+    followingOutput = true;
     appendTurn("user", userText, pendingTurnLabel);
     pendingTurnLabel = null;
     if (currentAbort) {
@@ -4625,6 +4768,10 @@ function boot(cfg) {
       var messages = [{ role: "system", content: currentSystemPrompt(resourceLines) }].concat(conversation.map(function(t) {
         return { role: t.role, content: t.content };
       })).concat([{ role: "user", content: userText }]);
+      conversation.push({ role: "user", content: userText });
+      var liveTurn = { role: "assistant", content: "", tools: [] };
+      conversation.push(liveTurn);
+      persistConversation();
       var result = await runChatLoop({
         baseUrl: LLM_BASE,
         toolHubUrl: TOOL_HUB_BASE,
@@ -4636,13 +4783,22 @@ 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();
         },
         onToolDispatched: function(outcome) {
           resolveToolCall(outcome);
+          liveTurn.tools = liveTurn.tools.concat([outcome.error ? { name: outcome.toolCall.name, error: true } : { name: outcome.toolCall.name }]);
+          persistConversation();
         },
         onPhase: function(name) {
           if (name === "responding") markDone(assistantBody.roleLabel);
@@ -4656,25 +4812,21 @@ function boot(cfg) {
           var body = ensureThinkingBlock();
           body.appendChild(document.createTextNode(delta));
           body.scrollTop = body.scrollHeight;
-          historyEl.scrollTop = historyEl.scrollHeight;
+          pinIfFollowing();
         },
         onTextDelta: function(delta) {
           markDone(assistantBody.roleLabel);
           collapseThinkingBlock();
           assistantMarkdown += delta;
           renderMarkdownInto(assistantBody, assistantMarkdown);
-          historyEl.scrollTop = historyEl.scrollHeight;
+          liveTurn.content = assistantMarkdown;
+          persistSoon();
+          pinIfFollowing();
         }
       });
-      conversation.push({ role: "user", content: userText });
-      conversation.push({
-        role: "assistant",
-        content: result.content,
-        // Kept so a restored transcript still shows what ran — losing
-        // that record is what made a navigating action unbearable.
-        tools: result.dispatched.map(function(d) {
-          return d.error ? { name: d.toolCall.name, error: true } : { name: d.toolCall.name };
-        })
+      liveTurn.content = result.content;
+      liveTurn.tools = result.dispatched.map(function(d) {
+        return d.error ? { name: d.toolCall.name, error: true } : { name: d.toolCall.name };
       });
       persistConversation();
       result.dispatched.forEach(function(d) {

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,111 @@ 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
+
+export function resourceBudgetBytes(window, { floor = 8000, cap = 64_000 } = {}) {
+  if (!window || !Number.isFinite(window)) return floor
+  const share = Math.round(window * RESOURCE_SHARE_OF_WINDOW * CHARS_PER_TOKEN)
+  return Math.min(cap, Math.max(floor, share))
+}
+
+// A rough token count, the same shape the hub's own estimator uses: characters
+// over four, plus a fixed cost per message. Deliberately approximate — it is
+// used to decide "drop the oldest tool result", never to fill the window
+// exactly, and it errs high so the decision is made early rather than late.
+export const CHARS_PER_TOKEN = 4
+export const MESSAGE_OVERHEAD_TOKENS = 4
+
+export function estimateTokens(messages) {
+  return (messages || []).reduce((sum, m) => {
+    const content = typeof m?.content === "string" ? m.content : JSON.stringify(m?.content ?? "")
+    return sum + Math.ceil(content.length / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD_TOKENS
+  }, 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("")
+  return Math.ceil(text.length / CHARS_PER_TOKEN)
+}
+
+// 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.0"
+  VERSION = "0.12.0"
 end

metadata

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