@aibranch/llm-meta-widget 0.11.0 → 0.12.0

package/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

package/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) {

package/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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aibranch/llm-meta-widget",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "//version": "Must stay in step with lib/llm_meta_widget/version.rb. Two independently versioned copies of the same client is the drift docs/custom-element-distribution.md warns about: bump both, release both.",
   "description": "Embeddable browser chat widget: a custom element that discovers tools at page, origin and hub scope and dispatches each tool call to the right one. Two lines of HTML on any host, Rails or not.",
   "keywords": [