llm_meta_widget 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6113516f03758b2dc602dd4f2e62b515206821b710c646c07faf474e1f9aa48
-  data.tar.gz: 5d65ceb25848ba253dfc61f92f04ed6f1110581fa5c3b7640c26718f2c4c4e51
+  metadata.gz: eea94229b42018fa2725d28578dd49970e9d0d3b2bc9bf095b9ac8fced1dcf80
+  data.tar.gz: 1b3c95b8632aa46d0bb6e8b338fae6ae2166356912629294e68db480e9124abf
 SHA512:
-  metadata.gz: 6b255c67fa8f44ccc1a7fcb71a2ccb149bf1e02f1441c7bbda31a22502f98c491902dd978c7817e411af5865a54557a89581ec36dbd64e41ada6a1722397d04d
-  data.tar.gz: dd5fa208a4fbb758fdcf7b9683f6102ea49b99270fd5a0e49182ab7eb21966705b6aca5ae7ee746694dd3a019ef6bdf662d0d24f57551dd2a8b86e0921cee0cd
+  metadata.gz: 7b6a4f6ac17d8601544fdb3ca94396b3482e66e13f3d5ba765c6d5839b608b17e692af5d7df16b51008a39ad527229193a8ce8d44345eb92feb98c31550f96b5
+  data.tar.gz: d8785730a6294fbfe926353c07ed3737add9ea8577a81cfc55471d020cfef51c641fdc735d5297a6701ab9cefe4b5a295df74c75897c84bac0e5f2c30e92f6d9

data/README.md

@@ -232,6 +232,23 @@ To lock the widget to the fixed `model:` prop and disable Class-1 tools entirely
 | `models:` | `nil` | Model-name allowlist; `nil` = all anon-available |
 | `hub_tools:` | `nil` | MCP-server-name allowlist; `nil` = all anon-public |
 
+## Surviving navigation
+
+A page action that navigates — submitting a form, following a link — no longer
+loses the conversation. The transcript, the record of which tools ran, and the
+model's own context are kept in `sessionStorage`: per tab, gone when the tab
+closes, never sent anywhere.
+
+The key is the page's **path**, not its full URL, so a form submit that returns
+to the same page with a new query string keeps the thread, while moving to a
+different page starts a fresh one. Nothing to configure.
+
+Two consequences worth knowing. An action of yours that navigates is now safe
+to declare — before this, offering one meant offering to wipe the visitor's
+chat. And if the navigation lands on an error page that does not render the
+widget, the conversation is still in storage but there is no panel to show it
+until the visitor returns to a page that has one.
+
 ## Choosing what answers the chat, and whose tools to offer
 
 Two independent settings, because they are two jobs. Neither implies the

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

@@ -1185,3 +1185,74 @@ export async function fetchOllamaModels({ baseUrl, signal }) {
     return []
   }
 }
+
+// ---- surviving navigation ------------------------------------------------
+//
+// A page action that navigates — submitting a form, following a link — used to
+// destroy the conversation, the record of what ran and the scroll position.
+// That made such actions unsafe to offer at all: PubDictionaries had to stop
+// declaring its submit action rather than let the assistant wipe the chat.
+//
+// The transcript is kept in sessionStorage: per tab, gone when the tab closes,
+// invisible to other visitors. Keyed by pathname rather than full URL, because
+// submitting a form usually returns to the same page with different query
+// parameters and that is exactly the case worth surviving.
+
+export const CONVERSATION_FORMAT = 1
+
+export function packConversation({ turns = [], open = false, model = null,
+                                   maxTurns = 40, maxBytes = 200000 } = {}) {
+  // Oldest turns go first when trimming: the recent ones carry the thread.
+  let kept = turns.slice(-maxTurns)
+  let payload = { v: CONVERSATION_FORMAT, savedAt: Date.now(), open, model, turns: kept }
+  let json = JSON.stringify(payload)
+
+  while (json.length > maxBytes && kept.length > 1) {
+    kept = kept.slice(1)
+    payload = { ...payload, turns: kept }
+    json = JSON.stringify(payload)
+  }
+  return json
+}
+
+export function unpackConversation(raw) {
+  if (!raw) return null
+  let payload
+  try {
+    payload = JSON.parse(raw)
+  } catch (e) {
+    return null
+  }
+  // A payload from a different format is not worth guessing at; starting
+  // fresh is better than rendering something half-understood.
+  if (!payload || payload.v !== CONVERSATION_FORMAT || !Array.isArray(payload.turns)) return null
+
+  const turns = payload.turns.filter((t) => t && typeof t.content === "string" &&
+                                            (t.role === "user" || t.role === "assistant"))
+  return { turns, open: !!payload.open, model: payload.model || null, savedAt: payload.savedAt || 0 }
+}
+
+// Storage can throw — private windows, blocked site data, quota — and none of
+// that is a reason for the widget to stop working.
+export function createConversationStore({ storage, key }) {
+  const safely = (fn, fallback = null) => {
+    try {
+      return fn()
+    } catch (e) {
+      return fallback
+    }
+  }
+
+  return {
+    key,
+    save(state) { return safely(() => { storage.setItem(key, packConversation(state)); return true }, false) },
+    load() { return safely(() => unpackConversation(storage.getItem(key))) },
+    clear() { return safely(() => { storage.removeItem(key); return true }, false) }
+  }
+}
+
+export function conversationKeyFor(location, prefix = "llm_meta_widget") {
+  // Path only: a form submit returns to the same page with a new query string,
+  // and that conversation is still the same conversation.
+  return `${prefix}:${location.pathname}`
+}

data/app/views/llm_meta_widget/_chat_panel.html.erb

@@ -452,7 +452,8 @@
 	import { runChatLoop, fetchMcpManifest, listMcpPrompts, getMcpPrompt,
 	         listMcpResources, readMcpResource, promptMessagesToText,
 	         loadHostResource, resourceLinesForTurn, resolvePromptArguments,
-	         promptButtonProps, promptArgumentSummary, fetchOllamaModels } from "<%= orchestrator_path %>";
+	         promptButtonProps, promptArgumentSummary, fetchOllamaModels,
+	         createConversationStore, conversationKeyFor } from "<%= orchestrator_path %>";
 	import { marked } from "/llm_meta_widget_assets/marked.esm.js";
 
 	// Standard prose settings — GFM (tables, autolinks, strikethrough),
@@ -504,23 +505,39 @@
 	var STORAGE_KEY_OPEN = "llm_meta_widget:open";
 	var STORAGE_KEY_SIZE = "llm_meta_widget:size";  // stored as "WxH" in px
 
+	// Floors matching the CSS min-width/min-height (24em / 16em). A panel
+	// measured mid-layout reports a few pixels; saving that produced a sliver
+	// anchored off the bottom of the window, and — worse — it was stored, so
+	// every later visit reopened at the sliver size. Sizes below the floor are
+	// neither saved nor honoured, which also heals a value already stored.
+	var MIN_SAVED_WIDTH  = 320;
+	var MIN_SAVED_HEIGHT = 240;
+
+	function plausibleSize(w, h) {
+		return w >= MIN_SAVED_WIDTH && h >= MIN_SAVED_HEIGHT &&
+		       w <= window.innerWidth * 2 && h <= window.innerHeight * 2;
+	}
+
 	function applyStoredSize() {
 		try {
 			var raw = localStorage.getItem(STORAGE_KEY_SIZE);
 			if (!raw) return;
 			var parts = raw.split("x");
 			var w = parseInt(parts[0], 10), h = parseInt(parts[1], 10);
-			if (w > 0 && h > 0) {
-				root.style.width  = w + "px";
-				root.style.height = h + "px";
+			if (!plausibleSize(w, h)) {
+				localStorage.removeItem(STORAGE_KEY_SIZE);   // heal a bad value
+				return;
 			}
+			root.style.width  = w + "px";
+			root.style.height = h + "px";
 		} catch (e) { /* noop */ }
 	}
 	function saveCurrentSize() {
 		try {
 			var rect = root.getBoundingClientRect();
-			localStorage.setItem(STORAGE_KEY_SIZE,
-				Math.round(rect.width) + "x" + Math.round(rect.height));
+			var w = Math.round(rect.width), h = Math.round(rect.height);
+			if (!plausibleSize(w, h)) return;   // layout noise, not a choice
+			localStorage.setItem(STORAGE_KEY_SIZE, w + "x" + h);
 		} catch (e) { /* noop */ }
 	}
 
@@ -528,13 +545,20 @@
 	// size it currently has. Uses top/left in pixels (required for CSS
 	// `resize: both` — a bottom/right-pinned element can't be dragged out
 	// past the viewport edge to grow).
-	function positionAtBottomRight() {
+	function positionAtBottomRight(attempt) {
 		var margin = 16;  // ~1em from the viewport edges
 		var rect = root.getBoundingClientRect();
 		var top  = Math.max(margin, window.innerHeight - rect.height - margin);
 		var left = Math.max(margin, window.innerWidth  - rect.width  - margin);
 		root.style.top  = top  + "px";
 		root.style.left = left + "px";
+
+		// Measured before layout settled: the panel reports a sliver and gets
+		// anchored to the very bottom of the window. Re-measure next frame.
+		var tries = attempt || 0;
+		if (rect.height < MIN_SAVED_HEIGHT && tries < 3 && typeof requestAnimationFrame === "function") {
+			requestAnimationFrame(function() { positionAtBottomRight(tries + 1); });
+		}
 	}
 
 	function setOpen(open) {
@@ -560,6 +584,9 @@
 	var initialOpen = false;
 	try { initialOpen = localStorage.getItem(STORAGE_KEY_OPEN) === "1"; } catch (e) { /* noop */ }
 	setOpen(initialOpen);
+	window.addEventListener("resize", function() {
+		if (!root.classList.contains("lmw-collapsed")) positionAtBottomRight();
+	});
 
 	toggleBtn.addEventListener("click", function() { setOpen(true); });
 	hideBtn.addEventListener("click", function() { setOpen(false); });
@@ -568,15 +595,39 @@
 	// continuously during a drag; save + reposition on each tick so the
 	// widget stays anchored to bottom-right as the user grows it.
 	if (typeof ResizeObserver === "function") {
+		var sawFirstResizeTick = false;
 		var ro = new ResizeObserver(function() {
 			if (root.classList.contains("lmw-collapsed")) return;
 			positionAtBottomRight();
+			// ResizeObserver always delivers an initial observation, and that
+			// one reports whatever the layout happened to be mid-boot. Only
+			// later ticks can be a user dragging the corner.
+			if (!sawFirstResizeTick) { sawFirstResizeTick = true; return; }
 			saveCurrentSize();
 		});
 		ro.observe(root);
 	}
 
-	var conversation = [];  // [{role, content}, ...] — grows across turns
+	// [{role, content, tools}] — grows across turns. `tools` is for the
+	// transcript only; the model is sent role and content.
+	var conversation = [];
+
+	// A page action that navigates used to take the conversation with it. The
+	// transcript lives in sessionStorage — per tab, gone when the tab closes —
+	// keyed by path, so submitting a form and landing back on the same page
+	// with a new query string keeps the thread.
+	var conversationStore = createConversationStore({
+		storage: window.sessionStorage,
+		key:     conversationKeyFor(window.location)
+	});
+
+	function persistConversation() {
+		conversationStore.save({
+			turns: conversation,
+			open:  !root.classList.contains("lmw-collapsed"),
+			model: MODEL
+		});
+	}
 	var actionsSchemaEl = document.getElementById(ACTIONS_SCHEMA_ID);
 	var localTools = actionsSchemaEl ? JSON.parse(actionsSchemaEl.textContent) : [];
 	var remoteToolsEl = document.getElementById(REMOTE_TOOLS_SCHEMA_ID);
@@ -845,6 +896,10 @@
 	var RESOURCE_BUDGET_BYTES = 8000;
 
 
+	// Before anything asynchronous: if this page was navigated away from and
+	// back, the visitor should see their conversation immediately.
+	restoreConversation();
+
 	var wellKnownReady = (async function() {
 		var urls = WELL_KNOWN_URLS === null
 			? [ window.location.origin + "/.well-known/mcp.json" ]
@@ -921,11 +976,39 @@
 		promptsEl.style.display = "";
 	}
 
+	// Put a saved transcript back on screen: the same bubbles, the same
+	// markdown, and the same record of which tools ran. Called once at boot,
+	// before the welcome block, which is only for a genuinely fresh start.
+	function restoreConversation() {
+		var saved = conversationStore.load();
+		if (!saved || !saved.turns.length) return false;
+
+		conversation = saved.turns;
+		saved.turns.forEach(function(turn) {
+			var body = appendTurn(turn.role, turn.role === "assistant" ? "" : turn.content);
+			if (turn.role === "assistant") renderMarkdownInto(body, turn.content || "");
+			if (!turn.tools || !turn.tools.length) return;
+			var row = document.createElement("div");
+			row.className = "lmw-tool-chips";
+			turn.tools.forEach(function(tool) {
+				var chip = document.createElement("span");
+				chip.className = "lmw-tool-chip" + (tool.error ? " error" : "");
+				chip.textContent = (tool.error ? "❌ " : "🔧 ") + tool.name;
+				row.appendChild(chip);
+			});
+			if (body.parentNode) body.parentNode.appendChild(row);
+		});
+		historyEl.scrollTop = historyEl.scrollHeight;
+		return true;
+	}
+
 	// A blank panel tells a first-time visitor nothing. Open with a greeting
 	// and the offers themselves — each template showing what it will take from
 	// the page and what it will ask for — so the assistant is the page's way
 	// in rather than a box you must already know how to talk to.
 	function renderWelcome() {
+		// A restored transcript is not a fresh start; the greeting would push
+		// the conversation the visitor is mid-way through off the screen.
 		if (!historyEl || historyEl.querySelector(".message")) return;
 		historyEl.textContent = "";
 
@@ -1238,6 +1321,7 @@
 	clearBtn.addEventListener("click", function() {
 		if (currentAbort) { try { currentAbort.abort(); } catch (e) { /* noop */ } }
 		conversation = [];
+		conversationStore.clear();
 		historyEl.innerHTML = "";
 		renderWelcome();
 	});
@@ -1280,7 +1364,7 @@
 
 			var resourceLines = await resourceLinesForThisTurn();
 			var messages = [{ role: "system", content: currentSystemPrompt(resourceLines) }]
-				.concat(conversation)
+				.concat(conversation.map(function(t) { return { role: t.role, content: t.content }; }))
 				.concat([{ role: "user", content: userText }]);
 
 			var result = await runChatLoop({
@@ -1331,8 +1415,17 @@
 					historyEl.scrollTop = historyEl.scrollHeight;
 				}
 			});
-			conversation.push({ role: "user",      content: userText });
-			conversation.push({ role: "assistant", content: result.content });
+			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 };
+				})
+			});
+			persistConversation();
 
 			// Anything still pending never reported an outcome (a class that
 			// does not round-trip, or a dispatch that vanished). Reconcile

data/lib/llm_meta_widget/version.rb

@@ -1,3 +1,3 @@
 module LlmMetaWidget
-  VERSION = "0.5.0"
+  VERSION = "0.6.1"
 end

metadata

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