llm_meta_widget 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f20be01e9b1ac0bfc27351f7c1583478eaf3f1c9c5a9ef0739f95e71f965b03
-  data.tar.gz: cb74a7a835799fb21b18ef51637f03320da067b37b955532705aae48ceb46df8
+  metadata.gz: 6d7a58b9b553be09b66ca6e9aa01f8264a280bb725f80820ec3de506573701ae
+  data.tar.gz: 7b171f0c86c5f45a6250975ab02da586d620602d8fc1bea95261dd963d17e67a
 SHA512:
-  metadata.gz: 21a3107c99ecb9d7f27aee4378f9f9e816bcdaf140421cddc32967d4df6703d577972c5087cb0efe17eeb2ad5a924f162b406c30dd50f2fcc07a1935f98ff3c7
-  data.tar.gz: 0fec2f2cf2ad99af3cf4c932f7c35028ddd0017e331a559d9d90b339a4ad8d3dc920a492fdb2dcdf21a050f7f7dd5a3722968598ff2dbc1c15906604bd613499
+  metadata.gz: e90d55856a37217816264730d1a65fd32af2ad4783ad0c1a09ed298fb5dfe35a618a1ca149bf77265aab346dba4437b960a98399e91b3b15695aa601ed9d2025
+  data.tar.gz: 042b6872987730e708758fee7c6043ac27b0a83b27935e33f0751a910307cd901e746f28a2557dc54dfc32f63d5a4039f43cefcbc1952d93613cc59568e4c44a

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

@@ -594,19 +594,20 @@ export async function fetchMcpManifest(manifestUrl) {
 // `result` value (or throws on JSON-RPC error / HTTP failure). Supports
 // both JSON and SSE responses (MCP over HTTP allows either).
 let _mcpReqId = 0
-export async function callMcpTool({ endpoint, name, args, signal }) {
+
+// One JSON-RPC round trip to an MCP endpoint. Extracted from callMcpTool so
+// prompts/* and resources/* reuse the same transport — MCP over HTTP may
+// answer with either JSON or SSE, and duplicating that handling per method
+// is how the two drift apart.
+export async function mcpRpc({ endpoint, method, params, signal, label }) {
+  const what = label || method
   const response = await fetch(endpoint, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       "Accept":       "application/json, text/event-stream"
     },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id:      ++_mcpReqId,
-      method:  "tools/call",
-      params:  { name, arguments: args || {} }
-    }),
+    body: JSON.stringify({ jsonrpc: "2.0", id: ++_mcpReqId, method, params: params || {} }),
     signal,
     // Send session cookies for same-origin MCP endpoints. Cross-origin CORS
     // with credentials requires the server to echo Access-Control-Allow-
@@ -617,16 +618,14 @@ export async function callMcpTool({ endpoint, name, args, signal }) {
   })
   if (!response.ok) {
     const text = await response.text().catch(() => "")
-    throw new Error(`callMcpTool(${name}): HTTP ${response.status}${text ? " — " + text.slice(0, 200) : ""}`)
+    throw new Error(`${what}: HTTP ${response.status}${text ? " — " + text.slice(0, 200) : ""}`)
   }
 
   const contentType = response.headers.get("content-type") || ""
 
   if (contentType.includes("application/json")) {
     const body = await response.json()
-    if (body?.error) {
-      throw new Error(`callMcpTool(${name}): ${body.error.message || "JSON-RPC error"}`)
-    }
+    if (body?.error) throw new Error(`${what}: ${body.error.message || "JSON-RPC error"}`)
     return body?.result
   }
 
@@ -635,15 +634,77 @@ export async function callMcpTool({ endpoint, name, args, signal }) {
     for await (const evt of parseSseStream(response.body, signal)) {
       const payload = evt.data
       if (!payload || typeof payload !== "object") continue
-      if (payload.error) {
-        throw new Error(`callMcpTool(${name}): ${payload.error.message || "JSON-RPC error"}`)
-      }
+      if (payload.error) throw new Error(`${what}: ${payload.error.message || "JSON-RPC error"}`)
       if ("result" in payload) return payload.result
     }
-    throw new Error(`callMcpTool(${name}): SSE stream ended without result`)
+    throw new Error(`${what}: SSE stream ended without result`)
   }
 
-  throw new Error(`callMcpTool(${name}): unexpected content-type ${contentType}`)
+  throw new Error(`${what}: unexpected content-type ${contentType}`)
+}
+
+export async function callMcpTool({ endpoint, name, args, signal }) {
+  return mcpRpc({
+    endpoint, signal, method: "tools/call",
+    params: { name, arguments: args || {} },
+    label: `callMcpTool(${name})`
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Prompt and resource primitives
+// ---------------------------------------------------------------------------
+//
+// Optional in MCP, so every one of these returns empty rather than throwing
+// when a server doesn't implement them: the widget must stay usable against a
+// tools-only server. A server that answers `prompts/list` with -32601 is
+// telling us "not supported"; one that errors some other way is broken, and
+// either way the widget carries on with whatever it did get.
+
+export async function listMcpPrompts({ endpoint, signal }) {
+  try {
+    const result = await mcpRpc({ endpoint, method: "prompts/list", signal })
+    return (result?.prompts || []).map((p) => ({ ...p, endpoint }))
+  } catch { return [] }
+}
+
+export async function getMcpPrompt({ endpoint, name, args, signal }) {
+  return mcpRpc({
+    endpoint, signal, method: "prompts/get",
+    params: { name, arguments: args || {} },
+    label: `getMcpPrompt(${name})`
+  })
+}
+
+export async function listMcpResources({ endpoint, signal }) {
+  try {
+    const result = await mcpRpc({ endpoint, method: "resources/list", signal })
+    return (result?.resources || []).map((r) => ({ ...r, endpoint }))
+  } catch { return [] }
+}
+
+export async function readMcpResource({ endpoint, uri, signal }) {
+  return mcpRpc({
+    endpoint, signal, method: "resources/read",
+    params: { uri }, label: `readMcpResource(${uri})`
+  })
+}
+
+// Flatten a prompts/get result into the plain string the hub's messages take.
+// The spec allows `content` to be an object or an array of content blocks;
+// anything non-text is dropped, which is worth knowing — a prompt carrying an
+// image would silently lose it on this path.
+export function promptMessagesToText(result) {
+  return (result?.messages || [])
+    .map((m) => {
+      const c = m.content
+      if (typeof c === "string") return c
+      if (Array.isArray(c)) return c.filter((b) => b?.type === "text").map((b) => b.text).join("\n")
+      if (c && c.type === "text") return c.text
+      return ""
+    })
+    .filter(Boolean)
+    .join("\n\n")
 }
 
 // Standalone remote dispatcher — POSTs one tool_call to the meta-server's
@@ -715,3 +776,205 @@ function parseSseFrame(raw) {
   }
   return { name, data }
 }
+
+// ---- static-primitives extension ---------------------------------------
+//
+// Prototype of `io.modelcontextprotocol/static-primitives` (the SEP-2127
+// follow-on). Three optional fields a server may declare on a resources/list
+// entry:
+//
+//   sizeBytes  - byte length of the payload resources/read would return, so a
+//                client can decide whether to attach it BEFORE fetching it.
+//   volatility - "stable" (content fixed) or "volatile" (varies between
+//                turns, so a client re-reads it each turn).
+//   autoAttach - may a client attach this without the user asking for it?
+//
+// volatility and autoAttach are separate on purpose. Whether content changes
+// says nothing about whether it may be attached unasked, and the client needs
+// autoAttach as a boolean anyway, because its own byte budget can withhold a
+// resource the server was happy to hand over.
+//
+// All three are optional, and a server declaring none must behave exactly as
+// it did before the extension existed: fetch once, trim to budget, attach on
+// the first turn only.
+export const STATIC_PRIMITIVES_META = "io.modelcontextprotocol/static-primitives"
+
+const VOLATILITIES = [ "stable", "volatile" ]
+
+export function resourceHints(entry) {
+  const meta = (entry && entry._meta && entry._meta[STATIC_PRIMITIVES_META]) || {}
+  return {
+    // A non-numeric or absent size means "unknown", never 0 — 0 would read
+    // as a free resource and sail through every budget check.
+    sizeBytes: typeof meta.sizeBytes === "number" && isFinite(meta.sizeBytes) ? meta.sizeBytes : null,
+    volatility: VOLATILITIES.indexOf(meta.volatility) === -1 ? "stable" : meta.volatility,
+    autoAttach: typeof meta.autoAttach === "boolean" ? meta.autoAttach : true
+  }
+}
+
+// The pre-flight decision, made from the resources/list entry alone.
+// `fetch: false` means the bytes never cross the wire at all.
+export function planResourceAttachment(entry, budgetBytes) {
+  const { sizeBytes, volatility, autoAttach } = resourceHints(entry)
+  const base = { sizeBytes, volatility, uri: entry && entry.uri }
+
+  if (!autoAttach) {
+    return { ...base, fetch: false, autoAttach: false, reason: "not-auto-attach" }
+  }
+  if (sizeBytes !== null && sizeBytes > budgetBytes) {
+    // The client's budget overrides the server's willingness — which is why
+    // autoAttach has to be a boolean here rather than a restatement of a hint.
+    return { ...base, fetch: false, autoAttach: false, reason: "over-budget" }
+  }
+  return {
+    ...base,
+    fetch: true,
+    autoAttach: true,
+    // Unknown size still gets fetched, then trimmed — the trim is the
+    // safety net for servers that do not declare a size.
+    reason: sizeBytes === null ? "size-unknown" : "within-budget"
+  }
+}
+
+// Per-turn gate. A stable resource is attached once and re-used; a volatile
+// one is owed a fresh copy every turn.
+export function createResourceAttacher(plan) {
+  let attachedOnce = false
+  return {
+    take() {
+      if (!plan || !plan.autoAttach) return false
+      if (plan.volatility === "volatile") return true
+      if (attachedOnce) return false
+      attachedOnce = true
+      return true
+    },
+    get volatility() { return plan ? plan.volatility : null }
+  }
+}
+
+// Safety net for a server that declares no size: shrink an oversized
+// catalog to its names rather than dropping it, and hard-truncate anything
+// that is not a recognised catalog shape.
+export function trimResourceText(text, maxBytes) {
+  if (text.length <= maxBytes) return text
+  try {
+    const parsed = JSON.parse(text)
+    const rows = parsed && parsed.dictionaries
+    if (Array.isArray(rows)) {
+      const names = rows.map((d) => d && d.name).filter(Boolean)
+      return JSON.stringify({ dictionaries: names, note: "names only — full catalog too large to inline" })
+    }
+  } catch (e) { /* fall through to a hard truncation */ }
+  return text.slice(0, maxBytes) + "\n…truncated"
+}
+
+// Read one resource and shape it for the system prompt. The trim is applied
+// on every read, not just the first: a declared size can go stale, and a
+// volatile resource is a fresh gamble each turn.
+async function readResourceContext({ endpoint, uri, name, read, budgetBytes }) {
+  try {
+    const result = await read({ endpoint, uri })
+    const entry = ((result && result.contents) || [])[0]
+    if (!entry || !entry.text) return null
+    return { uri, name: name || uri, text: trimResourceText(entry.text, budgetBytes) }
+  } catch (e) {
+    // Optional context — a failed read must never block the widget.
+    return null
+  }
+}
+
+// The discovery sequence for one endpoint's reference resource, kept here
+// rather than in the panel so the decision AND the call site are testable
+// together: a gate nothing consults is exactly the bug this shape prevents.
+//
+// A volatile resource is NOT read here. Its content is only meaningful for
+// the turn it is attached to, so reading it at boot would buy a copy that is
+// already suspect by the time anyone sends a message.
+export async function loadHostResource({ endpoint, budgetBytes, list, read, onSkip }) {
+  const resources = await list({ endpoint })
+  const candidate = (resources || []).filter((r) => (r.mimeType || "") === "application/json")[0]
+  if (!candidate) return null
+
+  const plan = planResourceAttachment(candidate, budgetBytes)
+  plan.name = candidate.name || candidate.uri
+  // Carried so a volatile re-read knows where to go: discovery happens once
+  // at boot, but the fetch it authorises happens on every later turn.
+  plan.endpoint = endpoint
+  if (!plan.fetch) {
+    if (onSkip) onSkip(plan)
+    return { plan, context: null }
+  }
+  if (plan.volatility === "volatile") return { plan, context: null }
+
+  const context = await readResourceContext({
+    endpoint, uri: candidate.uri, name: plan.name, read, budgetBytes
+  })
+  return { plan, context }
+}
+
+export function resourceContextLines(context) {
+  if (!context) return []
+  return [ "", "Reference data — " + context.name + " (" + context.uri + "):", context.text ]
+}
+
+// What to attach on THIS turn. Asking consumes the turn, so the decision and
+// the fetch live together: a stable resource re-uses the copy read at boot,
+// a volatile one is read again right now.
+export async function resourceLinesForTurn({ plan, attacher, cached, endpoint, read, budgetBytes }) {
+  if (!attacher || !attacher.take()) return { lines: [], cached }
+
+  if (plan && plan.volatility === "volatile") {
+    const fresh = await readResourceContext({
+      endpoint, uri: plan.uri, name: plan.name, read, budgetBytes
+    })
+    return fresh ? { lines: resourceContextLines(fresh), cached: fresh } : { lines: [], cached }
+  }
+
+  return { lines: resourceContextLines(cached), cached }
+}
+
+// ---- prompt templates ---------------------------------------------------
+//
+// A server-declared prompt is only useful if the HOST PAGE can fill its
+// arguments, so an argument is matched against the page's own state readers
+// (window.aiState) by name. `dictionaries` is read from a
+// `selected_dictionaries` reader: the page selects a LIST, and the prompt
+// declares the CSV shape the text_annotation tool already takes.
+const PROMPT_ARG_ALIASES = { dictionaries: "selected_dictionaries" }
+
+export function promptArgFromState(argName, state) {
+  const reader = (state && state[argName]) || (state && state[PROMPT_ARG_ALIASES[argName]])
+  if (typeof reader !== "function") return ""
+  let value
+  try {
+    value = reader()
+  } catch (e) {
+    // A throwing page reader is the page's bug, not a reason to break the
+    // widget; treat it as "nothing to fill with".
+    return ""
+  }
+  if (value === null || value === undefined) return ""
+  return Array.isArray(value) ? value.join(",") : String(value)
+}
+
+// Splits a prompt's declared arguments into what the page can supply and
+// what it cannot. Naming the missing ones lets the widget point at the empty
+// field on screen instead of relaying the server's -32602.
+export function resolvePromptArguments(prompt, state) {
+  const args = {}
+  const missing = []
+  for (const arg of (prompt && prompt.arguments) || []) {
+    const value = promptArgFromState(arg.name, state)
+    if (value) args[arg.name] = value
+    else if (arg.required) missing.push(arg.name)
+  }
+  return { args, missing }
+}
+
+export function promptButtonProps(prompt) {
+  return {
+    label: prompt.title || prompt.name,
+    title: prompt.description || ("Run the " + prompt.name + " prompt")
+  }
+}
+

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

@@ -268,6 +268,31 @@
 		border-radius: 8px;
 		padding: 8px;
 	}
+	/* Server-offered prompt templates. The row is display:none in markup and
+	 * gets its display back only when a prompt actually exists, so the inline
+	 * style and this rule have to agree on "flex". */
+	#llm-meta-widget-chat .lmw-prompts {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 6px;
+		margin-bottom: 8px;
+	}
+	#llm-meta-widget-chat .lmw-prompt {
+		background-color: #eff6ff;
+		color: #1d4ed8;
+		border: 1px solid #bfdbfe;
+		border-radius: 999px;
+		padding: 4px 12px;
+		font-size: 12px;
+		font-family: inherit;
+		cursor: pointer;
+		transition: background-color 0.2s, border-color 0.2s;
+	}
+	#llm-meta-widget-chat .lmw-prompt:hover:not(:disabled) {
+		background-color: #dbeafe;
+		border-color: #93c5fd;
+	}
+	#llm-meta-widget-chat .lmw-prompt:disabled { opacity: 0.5; cursor: default; }
 	#llm-meta-widget-chat .lmw-form { display: flex; flex-direction: column; gap: 8px; }
 	#llm-meta-widget-chat .lmw-input-wrapper { position: relative; flex: 1; }
 	#llm-meta-widget-chat .lmw-input {
@@ -326,6 +351,10 @@
 	</div>
 	<div class="lmw-messages"></div>
 	<div class="lmw-input-container">
+		<%# Server-offered prompt templates (MCP prompts/list). Hidden until a
+		    host MCP server actually offers one, so a tools-only server leaves
+		    the widget exactly as it was. %>
+		<div class="lmw-prompts" style="display:none"></div>
 		<form class="lmw-form">
 			<div class="lmw-input-wrapper">
 				<textarea class="lmw-input" placeholder="Enter your message..." rows="2" autocomplete="off"></textarea>
@@ -367,7 +396,10 @@
 </div>
 
 <script type="module">
-	import { runChatLoop, fetchMcpManifest } from "<%= orchestrator_path %>";
+	import { runChatLoop, fetchMcpManifest, listMcpPrompts, getMcpPrompt,
+	         listMcpResources, readMcpResource, promptMessagesToText,
+	         loadHostResource, createResourceAttacher, resourceLinesForTurn, resolvePromptArguments,
+	         promptButtonProps } from "<%= orchestrator_path %>";
 	import { marked } from "/llm_meta_widget_assets/marked.esm.js";
 
 	// Standard prose settings — GFM (tables, autolinks, strikethrough),
@@ -721,6 +753,20 @@
 	// Fetch well-known MCP manifests at boot. Auto-discovers same origin
 	// if WELL_KNOWN_URLS is null; empty array disables entirely.
 	var hostWideTools = [];
+	var hostWidePrompts = [];
+	var resourceContext = null;   // payload of the host's reference resource
+	var resourceAttacher = null;  // per-turn gate, built from the server's hint
+	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;
+
+	// Set when a server declared a resource we deliberately did not attach,
+	// so the reason is inspectable rather than a silent absence.
+	var resourceSkip = null;
+
 	var wellKnownReady = (async function() {
 		var urls = WELL_KNOWN_URLS === null
 			? [ window.location.origin + "/.well-known/mcp.json" ]
@@ -729,8 +775,103 @@
 			var tools = await fetchMcpManifest(urls[i]);
 			hostWideTools = hostWideTools.concat(tools);
 		}
+
+		// The manifest publishes TOOLS only, so the endpoints are learned from
+		// them. A server offering only prompts or resources is invisible here —
+		// worth knowing when deciding what a static manifest should carry.
+		var endpoints = [];
+		hostWideTools.forEach(function(t) {
+			if (t.endpoint && endpoints.indexOf(t.endpoint) === -1) endpoints.push(t.endpoint);
+		});
+
+		for (var j = 0; j < endpoints.length; j++) {
+			var endpoint = endpoints[j];
+			var prompts = await listMcpPrompts({ endpoint: endpoint });
+			hostWidePrompts = hostWidePrompts.concat(prompts);
+
+			if (resourcePlan === null) {
+				// Listing, size gate and read all live in the orchestrator, where
+				// they are tested together — a gate nothing consults is exactly
+				// the bug this shape prevents.
+				var loaded = await loadHostResource({
+					endpoint:    endpoint,
+					budgetBytes: RESOURCE_BUDGET_BYTES,
+					list:        listMcpResources,
+					read:        readMcpResource,
+					onSkip: function(plan) {
+						resourceSkip = plan;
+						console.info("[llm_meta_widget] not attaching " + plan.uri +
+						             " (" + plan.reason + ", sizeBytes=" + plan.sizeBytes + ")");
+					}
+				});
+				// A volatile resource comes back with no context — it is read
+				// per turn instead — so the plan, not the payload, is what says
+				// whether this endpoint offered anything worth attaching.
+				if (loaded && loaded.plan && loaded.plan.fetch) {
+					resourceContext  = loaded.context;
+					resourcePlan     = loaded.plan;
+					resourceAttacher = createResourceAttacher(loaded.plan);
+				}
+			}
+		}
+		renderPromptButtons();
 	})();
 
+	// ---- server-offered prompt templates --------------------------------
+	//
+	// One button per prompt the host's MCP server offers. Clicking it fills
+	// the prompt's arguments from page state, asks the server to materialise
+	// the message (prompts/get), then drops the text into the textarea and
+	// submits — so it travels the exact path a typed message does.
+
+	var promptsEl = root.querySelector(".lmw-prompts");
+
+	function renderPromptButtons() {
+		if (!promptsEl) return;
+		promptsEl.textContent = "";
+		if (!hostWidePrompts.length) { promptsEl.style.display = "none"; return; }
+
+		hostWidePrompts.forEach(function(prompt) {
+			var props = promptButtonProps(prompt);
+			var button = document.createElement("button");
+			button.type = "button";
+			button.className = "lmw-prompt";
+			button.textContent = props.label;
+			button.title = props.title;
+			button.addEventListener("click", function() { runPromptTemplate(prompt, button); });
+			promptsEl.appendChild(button);
+		});
+		promptsEl.style.display = "";
+	}
+
+	async function runPromptTemplate(prompt, button) {
+		var resolved = resolvePromptArguments(prompt, window[STATE_GLOBAL] || {});
+		var args = resolved.args;
+		var missing = resolved.missing;
+
+		// Say which page field is empty rather than letting the server answer
+		// -32602 for something the user can actually fix on screen.
+		if (missing.length) {
+			appendTurn("error", "Cannot run \"" + (prompt.title || prompt.name) + "\" yet — nothing to use for: " +
+			                     missing.join(", ") + ". Fill that in on the page first.");
+			return;
+		}
+
+		button.disabled = true;
+		try {
+			var result = await getMcpPrompt({ endpoint: prompt.endpoint, name: prompt.name, args: args });
+			var text = promptMessagesToText(result);
+			if (!text) { appendTurn("error", "The server returned an empty prompt."); return; }
+			inputEl.value = text;
+			if (typeof formEl.requestSubmit === "function") formEl.requestSubmit();
+			else formEl.dispatchEvent(new Event("submit", { cancelable: true }));
+		} catch (e) {
+			appendTurn("error", "Prompt failed: " + (e && e.message ? e.message : e));
+		} finally {
+			button.disabled = false;
+		}
+	}
+
 	function appendTurn(role, text) {
 		// Class names mirror llm_meta_chat's chats/_message.html.erb —
 		// `.message.<role>`, `.message-role`, `.message-content` — so the
@@ -822,7 +963,7 @@
 		return out;
 	}
 
-	function currentSystemPrompt() {
+	function currentSystemPrompt(resourceLines) {
 		return [
 			"You are integrated into a web page as an AI assistant. You have tools available to change page state or fetch information.",
 			"",
@@ -834,7 +975,27 @@
 			"",
 			"Current page state:",
 			JSON.stringify(currentPageState(), null, 2)
-		].join("\n");
+		].concat(resourceLines || []).join("\n");
+	}
+
+	// Whether to attach, and how often, is the SERVER's call — via the
+	// extension's autoAttach and volatility fields, which default to
+	// attach-once for a server that declares neither.
+	//
+	// Asking consumes the turn, and a volatile resource is re-read here rather
+	// than re-using the boot-time copy — so this runs once per send, before
+	// the system prompt is built.
+	async function resourceLinesForThisTurn() {
+		var turn = await resourceLinesForTurn({
+			plan:        resourcePlan,
+			attacher:    resourceAttacher,
+			cached:      resourceContext,
+			endpoint:    resourcePlan && resourcePlan.endpoint,
+			read:        readMcpResource,
+			budgetBytes: RESOURCE_BUDGET_BYTES
+		});
+		resourceContext = turn.cached;
+		return turn.lines;
 	}
 
 	// Per-turn AbortController — lets the Clear button (or a new submit)
@@ -845,6 +1006,9 @@
 		if (currentAbort) { try { currentAbort.abort(); } catch (e) { /* noop */ } }
 		conversation = [];
 		historyEl.innerHTML = "";
+		// Clear starts a new conversation, so a 'once' resource is owed to it
+		// again — the old boolean stayed latched and silently withheld it.
+		if (resourcePlan) resourceAttacher = createResourceAttacher(resourcePlan);
 	});
 
 	// Enter submits, Shift+Enter inserts a newline — matches llm_meta_chat's
@@ -868,16 +1032,21 @@
 		if (currentAbort) { try { currentAbort.abort(); } catch (e) { /* noop */ } }
 		currentAbort = new AbortController();
 
-		var messages = [{ role: "system", content: currentSystemPrompt() }]
-			.concat(conversation)
-			.concat([{ role: "user", content: userText }]);
-
 		var assistantBody = appendTurn("assistant", "");
 		var assistantMarkdown = "";  // accumulate raw markdown, re-render on each delta
 
 		try {
+			// Discovery has to finish before the system prompt is built: the
+			// resource catalog is attached to the first turn only, so building
+			// messages first would silently ship that turn without it AND mark
+			// it as sent.
 			await wellKnownReady;
 
+			var resourceLines = await resourceLinesForThisTurn();
+			var messages = [{ role: "system", content: currentSystemPrompt(resourceLines) }]
+				.concat(conversation)
+				.concat([{ role: "user", content: userText }]);
+
 			var result = await runChatLoop({
 				baseUrl:       META_BASE,
 				apiKeyUuid:    API_KEY_UUID,

data/lib/llm_meta_widget/version.rb

@@ -1,3 +1,3 @@
 module LlmMetaWidget
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

metadata

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