llm_meta_widget 0.6.1 → 0.7.0

data/app/assets/javascripts/llm_meta_widget/llm-meta-widget.js

@@ -0,0 +1,4429 @@
+// GENERATED by `npm run build` from element.js + config.js + orchestrator.js + marked.esm.js + conversation.css + panel.css.
+// Do not edit this file; edit the sources and rebuild. `npm test` fails if it drifts.
+
+
+// app/assets/javascripts/llm_meta_widget/orchestrator.js
+async function singleLlmCall({
+  baseUrl,
+  apiKeyUuid,
+  modelName,
+  messages,
+  toolIds = [],
+  localTools = [],
+  generationSettings = {},
+  bearerToken,
+  onTextDelta,
+  onThinkingDelta,
+  onToolCall,
+  onPhase,
+  signal
+}) {
+  if (!baseUrl || !apiKeyUuid || !modelName) {
+    throw new Error("singleLlmCall: baseUrl, apiKeyUuid, modelName are required");
+  }
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new Error("singleLlmCall: messages must be a non-empty array");
+  }
+  const url = `${baseUrl.replace(/\/$/, "")}/api/llm_api_keys/${encodeURIComponent(
+    apiKeyUuid
+  )}/models/${encodeURIComponent(modelName)}/single_llm_calls`;
+  const headers = { "Content-Type": "application/json", Accept: "text/event-stream" };
+  if (bearerToken) headers["Authorization"] = `Bearer ${bearerToken}`;
+  const body = JSON.stringify({
+    messages,
+    tool_ids: toolIds,
+    // Convert camelCase → snake_case at the wire boundary; the server's
+    // strong-params permits `input_schema:` and rejects `inputSchema:`.
+    local_tools: (localTools || []).map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema || t.inputSchema
+    })),
+    generation_settings: generationSettings
+  });
+  const response = await fetch(url, { method: "POST", headers, body, signal });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`singleLlmCall: HTTP ${response.status} ${response.statusText}${text ? " \u2014 " + text.slice(0, 200) : ""}`);
+  }
+  if (!response.body) {
+    throw new Error("singleLlmCall: response has no body (streaming unsupported?)");
+  }
+  const toolCalls = [];
+  let content = "";
+  let finishReason = null;
+  for await (const event of parseSseStream(response.body, signal)) {
+    switch (event.name) {
+      case "text_delta": {
+        const delta = event.data?.delta;
+        if (typeof delta === "string" && delta.length > 0) {
+          content += delta;
+          onTextDelta?.(delta);
+        }
+        break;
+      }
+      case "thinking_delta": {
+        const delta = event.data?.delta;
+        if (typeof delta === "string" && delta.length > 0) {
+          onThinkingDelta?.(delta);
+        }
+        break;
+      }
+      case "tool_call": {
+        const tc = event.data?.tool_call;
+        if (tc && tc.name) {
+          toolCalls.push(tc);
+          onToolCall?.(tc);
+        }
+        break;
+      }
+      case "phase": {
+        const name = event.data?.name;
+        if (typeof name === "string") onPhase?.(name);
+        break;
+      }
+      case "done": {
+        if (typeof event.data?.content === "string") content = event.data.content;
+        if (event.data?.finish_reason != null) finishReason = event.data.finish_reason;
+        return { content, finishReason, toolCalls };
+      }
+      case "error": {
+        const code = event.data?.code || "server_error";
+        const message = event.data?.message || "meta-server emitted an error event";
+        const err = new Error(`singleLlmCall: ${code}: ${message}`);
+        err.code = code;
+        throw err;
+      }
+    }
+  }
+  throw new Error("singleLlmCall: stream closed without done event");
+}
+async function* parseSseStream(readableStream, signal) {
+  const reader = readableStream.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  const onAbort = () => {
+    try {
+      reader.cancel();
+    } catch {
+    }
+  };
+  signal?.addEventListener("abort", onAbort);
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sepIdx;
+      while ((sepIdx = indexOfEither(buffer, "\n\n", "\r\n\r\n")) !== -1) {
+        const rawFrame = buffer.slice(0, sepIdx);
+        buffer = buffer.slice(
+          sepIdx + (buffer.slice(sepIdx, sepIdx + 4) === "\r\n\r\n" ? 4 : 2)
+        );
+        const parsed = parseSseFrame(rawFrame);
+        if (parsed) yield parsed;
+      }
+    }
+    if (buffer.trim().length > 0) {
+      const parsed = parseSseFrame(buffer);
+      if (parsed) yield parsed;
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function indexOfEither(str, a, b) {
+  const ai = str.indexOf(a);
+  const bi = str.indexOf(b);
+  if (ai === -1) return bi;
+  if (bi === -1) return ai;
+  return Math.min(ai, bi);
+}
+async function dispatchLocalToolCalls(toolCalls, aiActions) {
+  const dispatched = [];
+  const skipped = [];
+  for (const tc of toolCalls || []) {
+    const handler = aiActions?.[tc.name];
+    if (typeof handler !== "function") {
+      skipped.push(tc);
+      continue;
+    }
+    const args = coerceArguments(tc.arguments);
+    try {
+      const value = await handler(args);
+      dispatched.push({ toolCall: tc, value });
+    } catch (error) {
+      dispatched.push({ toolCall: tc, error });
+    }
+  }
+  return { dispatched, skipped };
+}
+async function runChatLoop(opts) {
+  const {
+    aiActions = {},
+    remoteTools = [],
+    hostWideTools = [],
+    maxRounds = 10,
+    // "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.
+    provider = "hub",
+    // Where Class 1 (hub-registered) tools are proxied. Usually the same
+    // llm_meta_server that answers the chat, but not when the chat goes
+    // straight to an Ollama — the tools still belong to the hub.
+    toolHubUrl,
+    signal,
+    onRoundStart,
+    onTextDelta,
+    onThinkingDelta,
+    onToolCall,
+    // Fired as each tool finishes, so a caller can show what ran WHILE the
+    // turn is still going. The returned `dispatched` array says the same
+    // thing, but only once the whole loop ends — which on a slow model is
+    // minutes after the work happened, with the user watching unnamed tools.
+    onToolDispatched,
+    onPhase,
+    ...singleOpts
+  } = opts;
+  const 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)];
+  const inlineByName = {};
+  for (const t of singleOpts.localTools || []) inlineByName[t.name] = t;
+  for (const t of hostWideTools || []) {
+    if (!inlineByName[t.name]) inlineByName[t.name] = { name: t.name, description: t.description, input_schema: t.input_schema };
+  }
+  const mergedLocalTools = Object.values(inlineByName);
+  const rounds = [];
+  const allDispatched = [];
+  const allSkipped = [];
+  let lastResult = null;
+  const seenToolCalls = /* @__PURE__ */ new Set();
+  const toolKey = (tc) => {
+    let args;
+    try {
+      args = coerceArguments(tc.arguments);
+    } catch {
+      args = tc.arguments;
+    }
+    let serialized;
+    try {
+      if (args && typeof args === "object" && !Array.isArray(args)) {
+        const sorted = Object.keys(args).sort().reduce((o, k) => {
+          o[k] = args[k];
+          return o;
+        }, {});
+        serialized = JSON.stringify(sorted);
+      } else {
+        serialized = JSON.stringify(args);
+      }
+    } catch {
+      serialized = String(args);
+    }
+    return tc.name + "
" + serialized;
+  };
+  for (let round = 0; round < maxRounds; round++) {
+    if (signal?.aborted) throw new DOMException("aborted", "AbortError");
+    onRoundStart?.(round);
+    const call = provider === "ollama" ? ollamaChatCall : singleLlmCall;
+    const turnResult = await call({
+      ...singleOpts,
+      messages,
+      toolIds,
+      localTools: mergedLocalTools,
+      signal,
+      onTextDelta: onTextDelta ? (d) => onTextDelta(d, round) : void 0,
+      onThinkingDelta: onThinkingDelta ? (d) => onThinkingDelta(d, round) : void 0,
+      onToolCall: onToolCall ? (t) => onToolCall(t, round) : void 0,
+      onPhase: onPhase ? (n) => onPhase(n, round) : void 0
+    });
+    lastResult = turnResult;
+    const localCalls = [];
+    const hostWideCalls = [];
+    const remoteCalls = [];
+    const unknownCalls = [];
+    const duplicateCalls = [];
+    const emittedCount = (turnResult.toolCalls || []).length;
+    for (const tc of turnResult.toolCalls || []) {
+      const key = toolKey(tc);
+      if (seenToolCalls.has(key)) {
+        duplicateCalls.push(tc);
+        continue;
+      }
+      seenToolCalls.add(key);
+      if (typeof aiActions[tc.name] === "function") localCalls.push(tc);
+      else if (hostWideByName[tc.name]) hostWideCalls.push(tc);
+      else if (remoteByName[tc.name]) remoteCalls.push(tc);
+      else unknownCalls.push(tc);
+    }
+    const allDuplicates = emittedCount > 0 && duplicateCalls.length === emittedCount;
+    if (allDuplicates) {
+      rounds.push({
+        round,
+        content: turnResult.content,
+        finishReason: turnResult.finishReason,
+        localCalls: [],
+        hostWideCalls: [],
+        remoteCalls: [],
+        unknownCalls: [],
+        duplicateCalls,
+        toolCalls: turnResult.toolCalls
+      });
+      return {
+        content: turnResult.content,
+        finishReason: turnResult.finishReason,
+        rounds,
+        dispatched: allDispatched,
+        skipped: allSkipped,
+        stopped_reason: "duplicate_tool_calls"
+      };
+    }
+    const localOut = await dispatchLocalToolCalls(localCalls, aiActions);
+    allDispatched.push(...localOut.dispatched);
+    const roundTripResults = [];
+    for (const { toolCall, value, error } of localOut.dispatched) {
+      onToolDispatched?.({ toolCall, value, error });
+      roundTripResults.push({
+        tc: toolCall,
+        result: error ? { error: String(error.message || error) } : { ok: true, applied: toolCall.name }
+      });
+    }
+    for (const tc of hostWideCalls) {
+      const tool = hostWideByName[tc.name];
+      const args = coerceArguments(tc.arguments);
+      try {
+        const value = await callMcpTool({ endpoint: tool.endpoint, name: tc.name, args, signal });
+        allDispatched.push({ toolCall: tc, value });
+        onToolDispatched?.({ toolCall: tc, value });
+        roundTripResults.push({ tc, result: value });
+      } catch (error) {
+        allDispatched.push({ toolCall: tc, error });
+        onToolDispatched?.({ toolCall: tc, error });
+        roundTripResults.push({ tc, result: { error: String(error.message || error) } });
+      }
+    }
+    for (const tc of remoteCalls) {
+      const tool = remoteByName[tc.name];
+      const args = coerceArguments(tc.arguments);
+      try {
+        const value = await dispatchRemoteToolCall({
+          baseUrl: toolHubUrl || singleOpts.baseUrl,
+          bearerToken: singleOpts.bearerToken,
+          toolId: tool.id,
+          args,
+          signal
+        });
+        allDispatched.push({ toolCall: tc, value });
+        onToolDispatched?.({ toolCall: tc, value });
+        roundTripResults.push({ tc, result: value });
+      } catch (error) {
+        allDispatched.push({ toolCall: tc, error });
+        onToolDispatched?.({ toolCall: tc, error });
+        roundTripResults.push({ tc, result: { error: String(error.message || error) } });
+      }
+    }
+    allSkipped.push(...unknownCalls);
+    rounds.push({
+      round,
+      content: turnResult.content,
+      finishReason: turnResult.finishReason,
+      localCalls,
+      hostWideCalls,
+      remoteCalls,
+      unknownCalls,
+      toolCalls: turnResult.toolCalls
+    });
+    if (roundTripResults.length === 0) {
+      return {
+        content: turnResult.content,
+        finishReason: turnResult.finishReason,
+        rounds,
+        dispatched: allDispatched,
+        skipped: allSkipped
+      };
+    }
+    messages.push({
+      role: "assistant",
+      content: turnResult.content || "",
+      tool_calls: turnResult.toolCalls
+    });
+    for (const { tc, result } of roundTripResults) {
+      messages.push({
+        role: "tool",
+        tool_call_id: tc.id || "",
+        name: tc.name,
+        content: typeof result === "string" ? result : JSON.stringify(result)
+      });
+    }
+  }
+  return {
+    content: lastResult?.content || "",
+    finishReason: lastResult?.finishReason || null,
+    rounds,
+    dispatched: allDispatched,
+    skipped: allSkipped,
+    stopped_reason: `max_rounds (${maxRounds}) exceeded`
+  };
+}
+async function fetchMcpManifest(manifestUrl) {
+  let manifest;
+  try {
+    const response = await fetch(manifestUrl);
+    if (!response.ok) return [];
+    manifest = await response.json();
+  } catch {
+    return [];
+  }
+  const base = new URL(manifestUrl);
+  const out = [];
+  for (const server of manifest?.servers || []) {
+    let endpoint;
+    try {
+      endpoint = new URL(server.url, base).toString();
+    } catch {
+      continue;
+    }
+    for (const tool of server.tools || []) {
+      if (!tool.name) continue;
+      out.push({
+        name: tool.name,
+        description: tool.description || "",
+        input_schema: tool.input_schema || tool.inputSchema || { type: "object", properties: {} },
+        endpoint,
+        serverName: server.name || null
+      });
+    }
+  }
+  return out;
+}
+var _mcpReqId = 0;
+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, params: params || {} }),
+    signal,
+    // Send session cookies for same-origin MCP endpoints. Cross-origin CORS
+    // with credentials requires the server to echo Access-Control-Allow-
+    // Credentials: true — which most MCP servers won't. This is fine: for
+    // cross-origin the widget doesn't send cookies; the server enforces
+    // its own auth (API key in header, etc.) if it wants any.
+    credentials: "same-origin"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`${what}: HTTP ${response.status}${text ? " \u2014 " + 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(`${what}: ${body.error.message || "JSON-RPC error"}`);
+    return body?.result;
+  }
+  if (contentType.includes("text/event-stream")) {
+    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(`${what}: ${payload.error.message || "JSON-RPC error"}`);
+      if ("result" in payload) return payload.result;
+    }
+    throw new Error(`${what}: SSE stream ended without result`);
+  }
+  throw new Error(`${what}: unexpected content-type ${contentType}`);
+}
+async function callMcpTool({ endpoint, name, args, signal }) {
+  return mcpRpc({
+    endpoint,
+    signal,
+    method: "tools/call",
+    params: { name, arguments: args || {} },
+    label: `callMcpTool(${name})`
+  });
+}
+async function listMcpPrompts({ endpoint, signal }) {
+  try {
+    const result = await mcpRpc({ endpoint, method: "prompts/list", signal });
+    return (result?.prompts || []).map((p) => ({ ...p, endpoint }));
+  } catch {
+    return [];
+  }
+}
+async function getMcpPrompt({ endpoint, name, args, signal }) {
+  return mcpRpc({
+    endpoint,
+    signal,
+    method: "prompts/get",
+    params: { name, arguments: args || {} },
+    label: `getMcpPrompt(${name})`
+  });
+}
+async function listMcpResources({ endpoint, signal }) {
+  try {
+    const result = await mcpRpc({ endpoint, method: "resources/list", signal });
+    return (result?.resources || []).map((r) => ({ ...r, endpoint }));
+  } catch {
+    return [];
+  }
+}
+async function readMcpResource({ endpoint, uri, signal }) {
+  return mcpRpc({
+    endpoint,
+    signal,
+    method: "resources/read",
+    params: { uri },
+    label: `readMcpResource(${uri})`
+  });
+}
+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");
+}
+async function dispatchRemoteToolCall({ baseUrl, bearerToken, toolId, args, signal }) {
+  if (!baseUrl || toolId == null) {
+    throw new Error("dispatchRemoteToolCall: baseUrl and toolId are required");
+  }
+  const url = `${baseUrl.replace(/\/$/, "")}/api/mcp_tools/${encodeURIComponent(toolId)}/call`;
+  const headers = { "Content-Type": "application/json" };
+  if (bearerToken) headers["Authorization"] = `Bearer ${bearerToken}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ arguments: args || {} }),
+    signal
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`dispatchRemoteToolCall: HTTP ${response.status} ${response.statusText}${text ? " \u2014 " + text.slice(0, 200) : ""}`);
+  }
+  const body = await response.json();
+  return body.result;
+}
+function coerceArguments(raw) {
+  if (raw == null) return {};
+  if (typeof raw === "object") return raw;
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return { _raw: raw };
+    }
+  }
+  return { _raw: raw };
+}
+function parseSseFrame(raw) {
+  let name = "message";
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0 || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") name = value;
+    else if (field === "data") dataLines.push(value);
+  }
+  if (dataLines.length === 0 && name === "message") return null;
+  const dataStr = dataLines.join("\n");
+  let data = null;
+  if (dataStr.length > 0) {
+    try {
+      data = JSON.parse(dataStr);
+    } catch (e) {
+      data = { _raw: dataStr, _parseError: e.message };
+    }
+  }
+  return { name, data };
+}
+var STATIC_PRIMITIVES_META = "io.modelcontextprotocol/static-primitives";
+var VOLATILITIES = ["stable", "volatile"];
+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
+  };
+}
+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) {
+    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"
+  };
+}
+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 \u2014 full catalog too large to inline" });
+    }
+  } catch (e) {
+  }
+  return text.slice(0, maxBytes) + "\n\u2026truncated";
+}
+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) {
+    return null;
+  }
+}
+async function loadHostResource({ endpoint, budgetBytes, list: list2, read, onSkip }) {
+  const resources = await list2({ 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;
+  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 };
+}
+function resourceContextLines(context) {
+  if (!context) return [];
+  return ["", "Reference data \u2014 " + context.name + " (" + context.uri + "):", context.text];
+}
+async function resourceLinesForTurn({ plan, cached, endpoint, read, budgetBytes }) {
+  if (!plan || !plan.autoAttach) return { lines: [], cached };
+  if (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 };
+}
+var PROMPT_ARG_ALIASES = { dictionaries: "selected_dictionaries" };
+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) {
+    return "";
+  }
+  if (value === null || value === void 0) return "";
+  return Array.isArray(value) ? value.join(",") : String(value);
+}
+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 };
+}
+function promptArgumentSummary(prompt, state) {
+  return (prompt && prompt.arguments || []).map((arg) => {
+    const value = promptArgFromState(arg.name, state);
+    return { name: arg.name, value, filled: value.length > 0, required: !!arg.required };
+  });
+}
+function promptButtonProps(prompt) {
+  return {
+    label: prompt.title || prompt.name,
+    title: prompt.description || "Run the " + prompt.name + " prompt"
+  };
+}
+async function* parseNdjsonStream(readableStream, signal) {
+  const reader = readableStream.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  const onAbort = () => {
+    try {
+      reader.cancel();
+    } catch {
+    }
+  };
+  signal?.addEventListener("abort", onAbort);
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        try {
+          yield JSON.parse(line);
+        } catch (e) {
+        }
+      }
+    }
+    const tail = buffer.trim();
+    if (tail) {
+      try {
+        yield JSON.parse(tail);
+      } catch (e) {
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function toolsForOllama(localTools) {
+  return (localTools || []).map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.input_schema || t.inputSchema || { type: "object", properties: {} }
+    }
+  }));
+}
+function messagesForOllama(messages) {
+  return (messages || []).map((m) => {
+    if (m.role === "tool") {
+      return { role: "tool", tool_name: m.name, content: m.content };
+    }
+    if (m.tool_calls) {
+      return {
+        role: m.role,
+        content: m.content || "",
+        tool_calls: m.tool_calls.map((tc) => ({
+          function: { name: tc.name, arguments: coerceArguments(tc.arguments) }
+        }))
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+}
+async function ollamaChatCall({
+  baseUrl,
+  modelName,
+  messages,
+  localTools = [],
+  generationSettings = {},
+  onTextDelta,
+  onThinkingDelta,
+  onToolCall,
+  onPhase,
+  signal
+}) {
+  if (!baseUrl || !modelName) throw new Error("ollamaChatCall: baseUrl and modelName are required");
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new Error("ollamaChatCall: messages must be a non-empty array");
+  }
+  const { think, ...options2 } = generationSettings || {};
+  const body = { model: modelName, messages: messagesForOllama(messages), stream: true };
+  if (localTools && localTools.length) body.tools = toolsForOllama(localTools);
+  if (think !== void 0) body.think = think;
+  if (Object.keys(options2).length) body.options = options2;
+  const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`ollamaChatCall: HTTP ${response.status} ${response.statusText}${text ? " \u2014 " + text.slice(0, 200) : ""}`);
+  }
+  if (!response.body) throw new Error("ollamaChatCall: response has no body (streaming unsupported?)");
+  const toolCalls = [];
+  let content = "";
+  let finishReason = null;
+  let announcedPhase = null;
+  const phase = (name) => {
+    if (announcedPhase === name) return;
+    announcedPhase = name;
+    onPhase?.(name);
+  };
+  for await (const frame of parseNdjsonStream(response.body, signal)) {
+    const message = frame.message || {};
+    if (message.thinking) {
+      phase("thinking");
+      onThinkingDelta?.(message.thinking);
+    }
+    if (message.content) {
+      phase("responding");
+      content += message.content;
+      onTextDelta?.(message.content);
+    }
+    for (const tc of message.tool_calls || []) {
+      const call = {
+        id: tc.id || `ollama-${toolCalls.length}`,
+        name: tc.function?.name,
+        arguments: tc.function?.arguments ?? {}
+      };
+      toolCalls.push(call);
+      onToolCall?.(call);
+    }
+    if (frame.done) finishReason = frame.done_reason || "stop";
+  }
+  return { content, toolCalls, finishReason };
+}
+async function fetchOllamaModels({ baseUrl, signal }) {
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/tags`, { signal });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return (data.models || []).map((m) => m.name).filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+var CONVERSATION_FORMAT = 1;
+function packConversation({
+  turns = [],
+  open = false,
+  model = null,
+  maxTurns = 40,
+  maxBytes = 2e5
+} = {}) {
+  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;
+}
+function unpackConversation(raw) {
+  if (!raw) return null;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (e) {
+    return null;
+  }
+  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 };
+}
+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);
+    }
+  };
+}
+function conversationKeyFor(location, prefix = "llm_meta_widget") {
+  return `${prefix}:${location.pathname}`;
+}
+
+// app/assets/javascripts/llm_meta_widget/marked.esm.js
+function _getDefaults() {
+  return {
+    async: false,
+    breaks: false,
+    extensions: null,
+    gfm: true,
+    hooks: null,
+    pedantic: false,
+    renderer: null,
+    silent: false,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+var _defaults = _getDefaults();
+function changeDefaults(newDefaults) {
+  _defaults = newDefaults;
+}
+var escapeTest = /[&<>"']/;
+var escapeReplace = new RegExp(escapeTest.source, "g");
+var escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
+var escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, "g");
+var escapeReplacements = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var getEscapeReplacement = (ch) => escapeReplacements[ch];
+function escape$1(html2, encode) {
+  if (encode) {
+    if (escapeTest.test(html2)) {
+      return html2.replace(escapeReplace, getEscapeReplacement);
+    }
+  } else {
+    if (escapeTestNoEncode.test(html2)) {
+      return html2.replace(escapeReplaceNoEncode, getEscapeReplacement);
+    }
+  }
+  return html2;
+}
+var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+function unescape(html2) {
+  return html2.replace(unescapeTest, (_, n) => {
+    n = n.toLowerCase();
+    if (n === "colon")
+      return ":";
+    if (n.charAt(0) === "#") {
+      return n.charAt(1) === "x" ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
+    }
+    return "";
+  });
+}
+var caret = /(^|[^\[])\^/g;
+function edit(regex, opt) {
+  let source = typeof regex === "string" ? regex : regex.source;
+  opt = opt || "";
+  const obj = {
+    replace: (name, val) => {
+      let valSource = typeof val === "string" ? val : val.source;
+      valSource = valSource.replace(caret, "$1");
+      source = source.replace(name, valSource);
+      return obj;
+    },
+    getRegex: () => {
+      return new RegExp(source, opt);
+    }
+  };
+  return obj;
+}
+function cleanUrl(href) {
+  try {
+    href = encodeURI(href).replace(/%25/g, "%");
+  } catch (e) {
+    return null;
+  }
+  return href;
+}
+var noopTest = { exec: () => null };
+function splitCells(tableRow, count) {
+  const row = tableRow.replace(/\|/g, (match, offset, str) => {
+    let escaped = false;
+    let curr = offset;
+    while (--curr >= 0 && str[curr] === "\\")
+      escaped = !escaped;
+    if (escaped) {
+      return "|";
+    } else {
+      return " |";
+    }
+  }), cells = row.split(/ \|/);
+  let i = 0;
+  if (!cells[0].trim()) {
+    cells.shift();
+  }
+  if (cells.length > 0 && !cells[cells.length - 1].trim()) {
+    cells.pop();
+  }
+  if (count) {
+    if (cells.length > count) {
+      cells.splice(count);
+    } else {
+      while (cells.length < count)
+        cells.push("");
+    }
+  }
+  for (; i < cells.length; i++) {
+    cells[i] = cells[i].trim().replace(/\\\|/g, "|");
+  }
+  return cells;
+}
+function rtrim(str, c, invert) {
+  const l = str.length;
+  if (l === 0) {
+    return "";
+  }
+  let suffLen = 0;
+  while (suffLen < l) {
+    const currChar = str.charAt(l - suffLen - 1);
+    if (currChar === c && !invert) {
+      suffLen++;
+    } else if (currChar !== c && invert) {
+      suffLen++;
+    } else {
+      break;
+    }
+  }
+  return str.slice(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+  if (str.indexOf(b[1]) === -1) {
+    return -1;
+  }
+  let level = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === "\\") {
+      i++;
+    } else if (str[i] === b[0]) {
+      level++;
+    } else if (str[i] === b[1]) {
+      level--;
+      if (level < 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function outputLink(cap, link2, raw, lexer2) {
+  const href = link2.href;
+  const title = link2.title ? escape$1(link2.title) : null;
+  const text = cap[1].replace(/\\([\[\]])/g, "$1");
+  if (cap[0].charAt(0) !== "!") {
+    lexer2.state.inLink = true;
+    const token = {
+      type: "link",
+      raw,
+      href,
+      title,
+      text,
+      tokens: lexer2.inlineTokens(text)
+    };
+    lexer2.state.inLink = false;
+    return token;
+  }
+  return {
+    type: "image",
+    raw,
+    href,
+    title,
+    text: escape$1(text)
+  };
+}
+function indentCodeCompensation(raw, text) {
+  const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+  if (matchIndentToCode === null) {
+    return text;
+  }
+  const indentToCode = matchIndentToCode[1];
+  return text.split("\n").map((node) => {
+    const matchIndentInNode = node.match(/^\s+/);
+    if (matchIndentInNode === null) {
+      return node;
+    }
+    const [indentInNode] = matchIndentInNode;
+    if (indentInNode.length >= indentToCode.length) {
+      return node.slice(indentToCode.length);
+    }
+    return node;
+  }).join("\n");
+}
+var _Tokenizer = class {
+  options;
+  rules;
+  // set by the lexer
+  lexer;
+  // set by the lexer
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  space(src) {
+    const cap = this.rules.block.newline.exec(src);
+    if (cap && cap[0].length > 0) {
+      return {
+        type: "space",
+        raw: cap[0]
+      };
+    }
+  }
+  code(src) {
+    const cap = this.rules.block.code.exec(src);
+    if (cap) {
+      const text = cap[0].replace(/^ {1,4}/gm, "");
+      return {
+        type: "code",
+        raw: cap[0],
+        codeBlockStyle: "indented",
+        text: !this.options.pedantic ? rtrim(text, "\n") : text
+      };
+    }
+  }
+  fences(src) {
+    const cap = this.rules.block.fences.exec(src);
+    if (cap) {
+      const raw = cap[0];
+      const text = indentCodeCompensation(raw, cap[3] || "");
+      return {
+        type: "code",
+        raw,
+        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : cap[2],
+        text
+      };
+    }
+  }
+  heading(src) {
+    const cap = this.rules.block.heading.exec(src);
+    if (cap) {
+      let text = cap[2].trim();
+      if (/#$/.test(text)) {
+        const trimmed = rtrim(text, "#");
+        if (this.options.pedantic) {
+          text = trimmed.trim();
+        } else if (!trimmed || / $/.test(trimmed)) {
+          text = trimmed.trim();
+        }
+      }
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[1].length,
+        text,
+        tokens: this.lexer.inline(text)
+      };
+    }
+  }
+  hr(src) {
+    const cap = this.rules.block.hr.exec(src);
+    if (cap) {
+      return {
+        type: "hr",
+        raw: cap[0]
+      };
+    }
+  }
+  blockquote(src) {
+    const cap = this.rules.block.blockquote.exec(src);
+    if (cap) {
+      let text = cap[0].replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, "\n    $1");
+      text = rtrim(text.replace(/^ *>[ \t]?/gm, ""), "\n");
+      const top = this.lexer.state.top;
+      this.lexer.state.top = true;
+      const tokens = this.lexer.blockTokens(text);
+      this.lexer.state.top = top;
+      return {
+        type: "blockquote",
+        raw: cap[0],
+        tokens,
+        text
+      };
+    }
+  }
+  list(src) {
+    let cap = this.rules.block.list.exec(src);
+    if (cap) {
+      let bull = cap[1].trim();
+      const isordered = bull.length > 1;
+      const list2 = {
+        type: "list",
+        raw: "",
+        ordered: isordered,
+        start: isordered ? +bull.slice(0, -1) : "",
+        loose: false,
+        items: []
+      };
+      bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
+      if (this.options.pedantic) {
+        bull = isordered ? bull : "[*+-]";
+      }
+      const itemRegex = new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`);
+      let raw = "";
+      let itemContents = "";
+      let endsWithBlankLine = false;
+      while (src) {
+        let endEarly = false;
+        if (!(cap = itemRegex.exec(src))) {
+          break;
+        }
+        if (this.rules.block.hr.test(src)) {
+          break;
+        }
+        raw = cap[0];
+        src = src.substring(raw.length);
+        let line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t) => " ".repeat(3 * t.length));
+        let nextLine = src.split("\n", 1)[0];
+        let indent = 0;
+        if (this.options.pedantic) {
+          indent = 2;
+          itemContents = line.trimStart();
+        } else {
+          indent = cap[2].search(/[^ ]/);
+          indent = indent > 4 ? 1 : indent;
+          itemContents = line.slice(indent);
+          indent += cap[1].length;
+        }
+        let blankLine = false;
+        if (!line && /^ *$/.test(nextLine)) {
+          raw += nextLine + "\n";
+          src = src.substring(nextLine.length + 1);
+          endEarly = true;
+        }
+        if (!endEarly) {
+          const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`);
+          const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
+          const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
+          const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
+          while (src) {
+            const rawLine = src.split("\n", 1)[0];
+            nextLine = rawLine;
+            if (this.options.pedantic) {
+              nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, "  ");
+            }
+            if (fencesBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (headingBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (nextBulletRegex.test(nextLine)) {
+              break;
+            }
+            if (hrRegex.test(src)) {
+              break;
+            }
+            if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) {
+              itemContents += "\n" + nextLine.slice(indent);
+            } else {
+              if (blankLine) {
+                break;
+              }
+              if (line.search(/[^ ]/) >= 4) {
+                break;
+              }
+              if (fencesBeginRegex.test(line)) {
+                break;
+              }
+              if (headingBeginRegex.test(line)) {
+                break;
+              }
+              if (hrRegex.test(line)) {
+                break;
+              }
+              itemContents += "\n" + nextLine;
+            }
+            if (!blankLine && !nextLine.trim()) {
+              blankLine = true;
+            }
+            raw += rawLine + "\n";
+            src = src.substring(rawLine.length + 1);
+            line = nextLine.slice(indent);
+          }
+        }
+        if (!list2.loose) {
+          if (endsWithBlankLine) {
+            list2.loose = true;
+          } else if (/\n *\n *$/.test(raw)) {
+            endsWithBlankLine = true;
+          }
+        }
+        let istask = null;
+        let ischecked;
+        if (this.options.gfm) {
+          istask = /^\[[ xX]\] /.exec(itemContents);
+          if (istask) {
+            ischecked = istask[0] !== "[ ] ";
+            itemContents = itemContents.replace(/^\[[ xX]\] +/, "");
+          }
+        }
+        list2.items.push({
+          type: "list_item",
+          raw,
+          task: !!istask,
+          checked: ischecked,
+          loose: false,
+          text: itemContents,
+          tokens: []
+        });
+        list2.raw += raw;
+      }
+      list2.items[list2.items.length - 1].raw = raw.trimEnd();
+      list2.items[list2.items.length - 1].text = itemContents.trimEnd();
+      list2.raw = list2.raw.trimEnd();
+      for (let i = 0; i < list2.items.length; i++) {
+        this.lexer.state.top = false;
+        list2.items[i].tokens = this.lexer.blockTokens(list2.items[i].text, []);
+        if (!list2.loose) {
+          const spacers = list2.items[i].tokens.filter((t) => t.type === "space");
+          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => /\n.*\n/.test(t.raw));
+          list2.loose = hasMultipleLineBreaks;
+        }
+      }
+      if (list2.loose) {
+        for (let i = 0; i < list2.items.length; i++) {
+          list2.items[i].loose = true;
+        }
+      }
+      return list2;
+    }
+  }
+  html(src) {
+    const cap = this.rules.block.html.exec(src);
+    if (cap) {
+      const token = {
+        type: "html",
+        block: true,
+        raw: cap[0],
+        pre: cap[1] === "pre" || cap[1] === "script" || cap[1] === "style",
+        text: cap[0]
+      };
+      return token;
+    }
+  }
+  def(src) {
+    const cap = this.rules.block.def.exec(src);
+    if (cap) {
+      const tag2 = cap[1].toLowerCase().replace(/\s+/g, " ");
+      const href = cap[2] ? cap[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "";
+      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : cap[3];
+      return {
+        type: "def",
+        tag: tag2,
+        raw: cap[0],
+        href,
+        title
+      };
+    }
+  }
+  table(src) {
+    const cap = this.rules.block.table.exec(src);
+    if (!cap) {
+      return;
+    }
+    if (!/[:|]/.test(cap[2])) {
+      return;
+    }
+    const headers = splitCells(cap[1]);
+    const aligns = cap[2].replace(/^\||\| *$/g, "").split("|");
+    const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : [];
+    const item = {
+      type: "table",
+      raw: cap[0],
+      header: [],
+      align: [],
+      rows: []
+    };
+    if (headers.length !== aligns.length) {
+      return;
+    }
+    for (const align of aligns) {
+      if (/^ *-+: *$/.test(align)) {
+        item.align.push("right");
+      } else if (/^ *:-+: *$/.test(align)) {
+        item.align.push("center");
+      } else if (/^ *:-+ *$/.test(align)) {
+        item.align.push("left");
+      } else {
+        item.align.push(null);
+      }
+    }
+    for (const header of headers) {
+      item.header.push({
+        text: header,
+        tokens: this.lexer.inline(header)
+      });
+    }
+    for (const row of rows) {
+      item.rows.push(splitCells(row, item.header.length).map((cell) => {
+        return {
+          text: cell,
+          tokens: this.lexer.inline(cell)
+        };
+      }));
+    }
+    return item;
+  }
+  lheading(src) {
+    const cap = this.rules.block.lheading.exec(src);
+    if (cap) {
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[2].charAt(0) === "=" ? 1 : 2,
+        text: cap[1],
+        tokens: this.lexer.inline(cap[1])
+      };
+    }
+  }
+  paragraph(src) {
+    const cap = this.rules.block.paragraph.exec(src);
+    if (cap) {
+      const text = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1];
+      return {
+        type: "paragraph",
+        raw: cap[0],
+        text,
+        tokens: this.lexer.inline(text)
+      };
+    }
+  }
+  text(src) {
+    const cap = this.rules.block.text.exec(src);
+    if (cap) {
+      return {
+        type: "text",
+        raw: cap[0],
+        text: cap[0],
+        tokens: this.lexer.inline(cap[0])
+      };
+    }
+  }
+  escape(src) {
+    const cap = this.rules.inline.escape.exec(src);
+    if (cap) {
+      return {
+        type: "escape",
+        raw: cap[0],
+        text: escape$1(cap[1])
+      };
+    }
+  }
+  tag(src) {
+    const cap = this.rules.inline.tag.exec(src);
+    if (cap) {
+      if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) {
+        this.lexer.state.inLink = true;
+      } else if (this.lexer.state.inLink && /^<\/a>/i.test(cap[0])) {
+        this.lexer.state.inLink = false;
+      }
+      if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+        this.lexer.state.inRawBlock = true;
+      } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+        this.lexer.state.inRawBlock = false;
+      }
+      return {
+        type: "html",
+        raw: cap[0],
+        inLink: this.lexer.state.inLink,
+        inRawBlock: this.lexer.state.inRawBlock,
+        block: false,
+        text: cap[0]
+      };
+    }
+  }
+  link(src) {
+    const cap = this.rules.inline.link.exec(src);
+    if (cap) {
+      const trimmedUrl = cap[2].trim();
+      if (!this.options.pedantic && /^</.test(trimmedUrl)) {
+        if (!/>$/.test(trimmedUrl)) {
+          return;
+        }
+        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
+        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+          return;
+        }
+      } else {
+        const lastParenIndex = findClosingBracket(cap[2], "()");
+        if (lastParenIndex > -1) {
+          const start = cap[0].indexOf("!") === 0 ? 5 : 4;
+          const linkLen = start + cap[1].length + lastParenIndex;
+          cap[2] = cap[2].substring(0, lastParenIndex);
+          cap[0] = cap[0].substring(0, linkLen).trim();
+          cap[3] = "";
+        }
+      }
+      let href = cap[2];
+      let title = "";
+      if (this.options.pedantic) {
+        const link2 = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+        if (link2) {
+          href = link2[1];
+          title = link2[3];
+        }
+      } else {
+        title = cap[3] ? cap[3].slice(1, -1) : "";
+      }
+      href = href.trim();
+      if (/^</.test(href)) {
+        if (this.options.pedantic && !/>$/.test(trimmedUrl)) {
+          href = href.slice(1);
+        } else {
+          href = href.slice(1, -1);
+        }
+      }
+      return outputLink(cap, {
+        href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
+        title: title ? title.replace(this.rules.inline.anyPunctuation, "$1") : title
+      }, cap[0], this.lexer);
+    }
+  }
+  reflink(src, links) {
+    let cap;
+    if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+      const linkString = (cap[2] || cap[1]).replace(/\s+/g, " ");
+      const link2 = links[linkString.toLowerCase()];
+      if (!link2) {
+        const text = cap[0].charAt(0);
+        return {
+          type: "text",
+          raw: text,
+          text
+        };
+      }
+      return outputLink(cap, link2, cap[0], this.lexer);
+    }
+  }
+  emStrong(src, maskedSrc, prevChar = "") {
+    let match = this.rules.inline.emStrongLDelim.exec(src);
+    if (!match)
+      return;
+    if (match[3] && prevChar.match(/[\p{L}\p{N}]/u))
+      return;
+    const nextChar = match[1] || match[2] || "";
+    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+      const lLength = [...match[0]].length - 1;
+      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+      const endReg = match[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      endReg.lastIndex = 0;
+      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+      while ((match = endReg.exec(maskedSrc)) != null) {
+        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+        if (!rDelim)
+          continue;
+        rLength = [...rDelim].length;
+        if (match[3] || match[4]) {
+          delimTotal += rLength;
+          continue;
+        } else if (match[5] || match[6]) {
+          if (lLength % 3 && !((lLength + rLength) % 3)) {
+            midDelimTotal += rLength;
+            continue;
+          }
+        }
+        delimTotal -= rLength;
+        if (delimTotal > 0)
+          continue;
+        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+        const lastCharLength = [...match[0]][0].length;
+        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
+        if (Math.min(lLength, rLength) % 2) {
+          const text2 = raw.slice(1, -1);
+          return {
+            type: "em",
+            raw,
+            text: text2,
+            tokens: this.lexer.inlineTokens(text2)
+          };
+        }
+        const text = raw.slice(2, -2);
+        return {
+          type: "strong",
+          raw,
+          text,
+          tokens: this.lexer.inlineTokens(text)
+        };
+      }
+    }
+  }
+  codespan(src) {
+    const cap = this.rules.inline.code.exec(src);
+    if (cap) {
+      let text = cap[2].replace(/\n/g, " ");
+      const hasNonSpaceChars = /[^ ]/.test(text);
+      const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+        text = text.substring(1, text.length - 1);
+      }
+      text = escape$1(text, true);
+      return {
+        type: "codespan",
+        raw: cap[0],
+        text
+      };
+    }
+  }
+  br(src) {
+    const cap = this.rules.inline.br.exec(src);
+    if (cap) {
+      return {
+        type: "br",
+        raw: cap[0]
+      };
+    }
+  }
+  del(src) {
+    const cap = this.rules.inline.del.exec(src);
+    if (cap) {
+      return {
+        type: "del",
+        raw: cap[0],
+        text: cap[2],
+        tokens: this.lexer.inlineTokens(cap[2])
+      };
+    }
+  }
+  autolink(src) {
+    const cap = this.rules.inline.autolink.exec(src);
+    if (cap) {
+      let text, href;
+      if (cap[2] === "@") {
+        text = escape$1(cap[1]);
+        href = "mailto:" + text;
+      } else {
+        text = escape$1(cap[1]);
+        href = text;
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text,
+            text
+          }
+        ]
+      };
+    }
+  }
+  url(src) {
+    let cap;
+    if (cap = this.rules.inline.url.exec(src)) {
+      let text, href;
+      if (cap[2] === "@") {
+        text = escape$1(cap[0]);
+        href = "mailto:" + text;
+      } else {
+        let prevCapZero;
+        do {
+          prevCapZero = cap[0];
+          cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+        } while (prevCapZero !== cap[0]);
+        text = escape$1(cap[0]);
+        if (cap[1] === "www.") {
+          href = "http://" + cap[0];
+        } else {
+          href = cap[0];
+        }
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text,
+            text
+          }
+        ]
+      };
+    }
+  }
+  inlineText(src) {
+    const cap = this.rules.inline.text.exec(src);
+    if (cap) {
+      let text;
+      if (this.lexer.state.inRawBlock) {
+        text = cap[0];
+      } else {
+        text = escape$1(cap[0]);
+      }
+      return {
+        type: "text",
+        raw: cap[0],
+        text
+      };
+    }
+  }
+};
+var newline = /^(?: *(?:\n|$))+/;
+var blockCode = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/;
+var fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var bullet = /(?:[*+-]|\d{1,9}[.)])/;
+var lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bullet).replace(/blockCode/g, / {4}/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).getRegex();
+var _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var blockText = /^[^\n]+/;
+var _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+var def = edit(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+var _tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var html = edit("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", "i").replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
+var blockNormal = {
+  blockquote,
+  code: blockCode,
+  def,
+  fences,
+  heading,
+  hr,
+  html,
+  lheading,
+  list,
+  newline,
+  paragraph,
+  table: noopTest,
+  text: blockText
+};
+var gfmTable = edit("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockGfm = {
+  ...blockNormal,
+  table: gfmTable,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+};
+var blockPedantic = {
+  ...blockNormal,
+  html: edit(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", _comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+  heading: /^(#{1,6})(.*)(?:\n+|$)/,
+  fences: noopTest,
+  // fences not supported
+  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+};
+var escape = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var br = /^( {2,}|\\)\n(?!\s*$)/;
+var inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _punctuation = "\\p{P}\\p{S}";
+var punctuation = edit(/^((?![*_])[\spunctuation])/, "u").replace(/punctuation/g, _punctuation).getRegex();
+var blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
+var emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimAst = edit("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimUnd = edit("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, _punctuation).getRegex();
+var anyPunctuation = edit(/\\([punct])/, "gu").replace(/punct/g, _punctuation).getRegex();
+var autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+var tag = edit("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+var link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+var nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+var reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
+var inlineNormal = {
+  _backpedal: noopTest,
+  // only used for GFM url
+  anyPunctuation,
+  autolink,
+  blockSkip,
+  br,
+  code: inlineCode,
+  del: noopTest,
+  emStrongLDelim,
+  emStrongRDelimAst,
+  emStrongRDelimUnd,
+  escape,
+  link,
+  nolink,
+  punctuation,
+  reflink,
+  reflinkSearch,
+  tag,
+  text: inlineText,
+  url: noopTest
+};
+var inlinePedantic = {
+  ...inlineNormal,
+  link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", _inlineLabel).getRegex(),
+  reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", _inlineLabel).getRegex()
+};
+var inlineGfm = {
+  ...inlineNormal,
+  escape: edit(escape).replace("])", "~|])").getRegex(),
+  url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+  _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+  del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+};
+var inlineBreaks = {
+  ...inlineGfm,
+  br: edit(br).replace("{2,}", "*").getRegex(),
+  text: edit(inlineGfm.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+};
+var block = {
+  normal: blockNormal,
+  gfm: blockGfm,
+  pedantic: blockPedantic
+};
+var inline = {
+  normal: inlineNormal,
+  gfm: inlineGfm,
+  breaks: inlineBreaks,
+  pedantic: inlinePedantic
+};
+var _Lexer = class __Lexer {
+  tokens;
+  options;
+  state;
+  tokenizer;
+  inlineQueue;
+  constructor(options2) {
+    this.tokens = [];
+    this.tokens.links = /* @__PURE__ */ Object.create(null);
+    this.options = options2 || _defaults;
+    this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
+    this.tokenizer = this.options.tokenizer;
+    this.tokenizer.options = this.options;
+    this.tokenizer.lexer = this;
+    this.inlineQueue = [];
+    this.state = {
+      inLink: false,
+      inRawBlock: false,
+      top: true
+    };
+    const rules = {
+      block: block.normal,
+      inline: inline.normal
+    };
+    if (this.options.pedantic) {
+      rules.block = block.pedantic;
+      rules.inline = inline.pedantic;
+    } else if (this.options.gfm) {
+      rules.block = block.gfm;
+      if (this.options.breaks) {
+        rules.inline = inline.breaks;
+      } else {
+        rules.inline = inline.gfm;
+      }
+    }
+    this.tokenizer.rules = rules;
+  }
+  /**
+   * Expose Rules
+   */
+  static get rules() {
+    return {
+      block,
+      inline
+    };
+  }
+  /**
+   * Static Lex Method
+   */
+  static lex(src, options2) {
+    const lexer2 = new __Lexer(options2);
+    return lexer2.lex(src);
+  }
+  /**
+   * Static Lex Inline Method
+   */
+  static lexInline(src, options2) {
+    const lexer2 = new __Lexer(options2);
+    return lexer2.inlineTokens(src);
+  }
+  /**
+   * Preprocessing
+   */
+  lex(src) {
+    src = src.replace(/\r\n|\r/g, "\n");
+    this.blockTokens(src, this.tokens);
+    for (let i = 0; i < this.inlineQueue.length; i++) {
+      const next = this.inlineQueue[i];
+      this.inlineTokens(next.src, next.tokens);
+    }
+    this.inlineQueue = [];
+    return this.tokens;
+  }
+  blockTokens(src, tokens = []) {
+    if (this.options.pedantic) {
+      src = src.replace(/\t/g, "    ").replace(/^ +$/gm, "");
+    } else {
+      src = src.replace(/^( *)(\t+)/gm, (_, leading, tabs) => {
+        return leading + "    ".repeat(tabs.length);
+      });
+    }
+    let token;
+    let lastToken;
+    let cutSrc;
+    let lastParagraphClipped;
+    while (src) {
+      if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.space(src)) {
+        src = src.substring(token.raw.length);
+        if (token.raw.length === 1 && tokens.length > 0) {
+          tokens[tokens.length - 1].raw += "\n";
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.code(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.fences(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.heading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.hr(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.blockquote(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.list(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.html(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.def(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.raw;
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else if (!this.tokens.links[token.tag]) {
+          this.tokens.links[token.tag] = {
+            href: token.href,
+            title: token.title
+          };
+        }
+        continue;
+      }
+      if (token = this.tokenizer.table(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.lheading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      cutSrc = src;
+      if (this.options.extensions && this.options.extensions.startBlock) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startBlock.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
+        lastToken = tokens[tokens.length - 1];
+        if (lastParagraphClipped && lastToken.type === "paragraph") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        lastParagraphClipped = cutSrc.length !== src.length;
+        src = src.substring(token.raw.length);
+        continue;
+      }
+      if (token = this.tokenizer.text(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && lastToken.type === "text") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    this.state.top = true;
+    return tokens;
+  }
+  inline(src, tokens = []) {
+    this.inlineQueue.push({ src, tokens });
+    return tokens;
+  }
+  /**
+   * Lexing/Compiling
+   */
+  inlineTokens(src, tokens = []) {
+    let token, lastToken, cutSrc;
+    let maskedSrc = src;
+    let match;
+    let keepPrevChar, prevChar;
+    if (this.tokens.links) {
+      const links = Object.keys(this.tokens.links);
+      if (links.length > 0) {
+        while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
+          if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) {
+            maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+          }
+        }
+      }
+    }
+    while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    }
+    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    }
+    while (src) {
+      if (!keepPrevChar) {
+        prevChar = "";
+      }
+      keepPrevChar = false;
+      if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.escape(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.tag(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && token.type === "text" && lastToken.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.link(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.reflink(src, this.tokens.links)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && token.type === "text" && lastToken.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.codespan(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.br(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.del(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.autolink(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (!this.state.inLink && (token = this.tokenizer.url(src))) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      cutSrc = src;
+      if (this.options.extensions && this.options.extensions.startInline) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startInline.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (token = this.tokenizer.inlineText(cutSrc)) {
+        src = src.substring(token.raw.length);
+        if (token.raw.slice(-1) !== "_") {
+          prevChar = token.raw.slice(-1);
+        }
+        keepPrevChar = true;
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && lastToken.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    return tokens;
+  }
+};
+var _Renderer = class {
+  options;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  code(code, infostring, escaped) {
+    const lang = (infostring || "").match(/^\S*/)?.[0];
+    code = code.replace(/\n$/, "") + "\n";
+    if (!lang) {
+      return "<pre><code>" + (escaped ? code : escape$1(code, true)) + "</code></pre>\n";
+    }
+    return '<pre><code class="language-' + escape$1(lang) + '">' + (escaped ? code : escape$1(code, true)) + "</code></pre>\n";
+  }
+  blockquote(quote) {
+    return `<blockquote>
+${quote}</blockquote>
+`;
+  }
+  html(html2, block2) {
+    return html2;
+  }
+  heading(text, level, raw) {
+    return `<h${level}>${text}</h${level}>
+`;
+  }
+  hr() {
+    return "<hr>\n";
+  }
+  list(body, ordered, start) {
+    const type = ordered ? "ol" : "ul";
+    const startatt = ordered && start !== 1 ? ' start="' + start + '"' : "";
+    return "<" + type + startatt + ">\n" + body + "</" + type + ">\n";
+  }
+  listitem(text, task, checked) {
+    return `<li>${text}</li>
+`;
+  }
+  checkbox(checked) {
+    return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph(text) {
+    return `<p>${text}</p>
+`;
+  }
+  table(header, body) {
+    if (body)
+      body = `<tbody>${body}</tbody>`;
+    return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
+  }
+  tablerow(content) {
+    return `<tr>
+${content}</tr>
+`;
+  }
+  tablecell(content, flags) {
+    const type = flags.header ? "th" : "td";
+    const tag2 = flags.align ? `<${type} align="${flags.align}">` : `<${type}>`;
+    return tag2 + content + `</${type}>
+`;
+  }
+  /**
+   * span level renderer
+   */
+  strong(text) {
+    return `<strong>${text}</strong>`;
+  }
+  em(text) {
+    return `<em>${text}</em>`;
+  }
+  codespan(text) {
+    return `<code>${text}</code>`;
+  }
+  br() {
+    return "<br>";
+  }
+  del(text) {
+    return `<del>${text}</del>`;
+  }
+  link(href, title, text) {
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return text;
+    }
+    href = cleanHref;
+    let out = '<a href="' + href + '"';
+    if (title) {
+      out += ' title="' + title + '"';
+    }
+    out += ">" + text + "</a>";
+    return out;
+  }
+  image(href, title, text) {
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return text;
+    }
+    href = cleanHref;
+    let out = `<img src="${href}" alt="${text}"`;
+    if (title) {
+      out += ` title="${title}"`;
+    }
+    out += ">";
+    return out;
+  }
+  text(text) {
+    return text;
+  }
+};
+var _TextRenderer = class {
+  // no need for block level renderers
+  strong(text) {
+    return text;
+  }
+  em(text) {
+    return text;
+  }
+  codespan(text) {
+    return text;
+  }
+  del(text) {
+    return text;
+  }
+  html(text) {
+    return text;
+  }
+  text(text) {
+    return text;
+  }
+  link(href, title, text) {
+    return "" + text;
+  }
+  image(href, title, text) {
+    return "" + text;
+  }
+  br() {
+    return "";
+  }
+};
+var _Parser = class __Parser {
+  options;
+  renderer;
+  textRenderer;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+    this.options.renderer = this.options.renderer || new _Renderer();
+    this.renderer = this.options.renderer;
+    this.renderer.options = this.options;
+    this.textRenderer = new _TextRenderer();
+  }
+  /**
+   * Static Parse Method
+   */
+  static parse(tokens, options2) {
+    const parser2 = new __Parser(options2);
+    return parser2.parse(tokens);
+  }
+  /**
+   * Static Parse Inline Method
+   */
+  static parseInline(tokens, options2) {
+    const parser2 = new __Parser(options2);
+    return parser2.parseInline(tokens);
+  }
+  /**
+   * Parse Loop
+   */
+  parse(tokens, top = true) {
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+        const genericToken = token;
+        const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+        if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      switch (token.type) {
+        case "space": {
+          continue;
+        }
+        case "hr": {
+          out += this.renderer.hr();
+          continue;
+        }
+        case "heading": {
+          const headingToken = token;
+          out += this.renderer.heading(this.parseInline(headingToken.tokens), headingToken.depth, unescape(this.parseInline(headingToken.tokens, this.textRenderer)));
+          continue;
+        }
+        case "code": {
+          const codeToken = token;
+          out += this.renderer.code(codeToken.text, codeToken.lang, !!codeToken.escaped);
+          continue;
+        }
+        case "table": {
+          const tableToken = token;
+          let header = "";
+          let cell = "";
+          for (let j = 0; j < tableToken.header.length; j++) {
+            cell += this.renderer.tablecell(this.parseInline(tableToken.header[j].tokens), { header: true, align: tableToken.align[j] });
+          }
+          header += this.renderer.tablerow(cell);
+          let body = "";
+          for (let j = 0; j < tableToken.rows.length; j++) {
+            const row = tableToken.rows[j];
+            cell = "";
+            for (let k = 0; k < row.length; k++) {
+              cell += this.renderer.tablecell(this.parseInline(row[k].tokens), { header: false, align: tableToken.align[k] });
+            }
+            body += this.renderer.tablerow(cell);
+          }
+          out += this.renderer.table(header, body);
+          continue;
+        }
+        case "blockquote": {
+          const blockquoteToken = token;
+          const body = this.parse(blockquoteToken.tokens);
+          out += this.renderer.blockquote(body);
+          continue;
+        }
+        case "list": {
+          const listToken = token;
+          const ordered = listToken.ordered;
+          const start = listToken.start;
+          const loose = listToken.loose;
+          let body = "";
+          for (let j = 0; j < listToken.items.length; j++) {
+            const item = listToken.items[j];
+            const checked = item.checked;
+            const task = item.task;
+            let itemBody = "";
+            if (item.task) {
+              const checkbox = this.renderer.checkbox(!!checked);
+              if (loose) {
+                if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
+                  item.tokens[0].text = checkbox + " " + item.tokens[0].text;
+                  if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
+                    item.tokens[0].tokens[0].text = checkbox + " " + item.tokens[0].tokens[0].text;
+                  }
+                } else {
+                  item.tokens.unshift({
+                    type: "text",
+                    text: checkbox + " "
+                  });
+                }
+              } else {
+                itemBody += checkbox + " ";
+              }
+            }
+            itemBody += this.parse(item.tokens, loose);
+            body += this.renderer.listitem(itemBody, task, !!checked);
+          }
+          out += this.renderer.list(body, ordered, start);
+          continue;
+        }
+        case "html": {
+          const htmlToken = token;
+          out += this.renderer.html(htmlToken.text, htmlToken.block);
+          continue;
+        }
+        case "paragraph": {
+          const paragraphToken = token;
+          out += this.renderer.paragraph(this.parseInline(paragraphToken.tokens));
+          continue;
+        }
+        case "text": {
+          let textToken = token;
+          let body = textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text;
+          while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+            textToken = tokens[++i];
+            body += "\n" + (textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text);
+          }
+          out += top ? this.renderer.paragraph(body) : body;
+          continue;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Parse Inline Tokens
+   */
+  parseInline(tokens, renderer) {
+    renderer = renderer || this.renderer;
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+        const ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
+        if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(token.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      switch (token.type) {
+        case "escape": {
+          const escapeToken = token;
+          out += renderer.text(escapeToken.text);
+          break;
+        }
+        case "html": {
+          const tagToken = token;
+          out += renderer.html(tagToken.text);
+          break;
+        }
+        case "link": {
+          const linkToken = token;
+          out += renderer.link(linkToken.href, linkToken.title, this.parseInline(linkToken.tokens, renderer));
+          break;
+        }
+        case "image": {
+          const imageToken = token;
+          out += renderer.image(imageToken.href, imageToken.title, imageToken.text);
+          break;
+        }
+        case "strong": {
+          const strongToken = token;
+          out += renderer.strong(this.parseInline(strongToken.tokens, renderer));
+          break;
+        }
+        case "em": {
+          const emToken = token;
+          out += renderer.em(this.parseInline(emToken.tokens, renderer));
+          break;
+        }
+        case "codespan": {
+          const codespanToken = token;
+          out += renderer.codespan(codespanToken.text);
+          break;
+        }
+        case "br": {
+          out += renderer.br();
+          break;
+        }
+        case "del": {
+          const delToken = token;
+          out += renderer.del(this.parseInline(delToken.tokens, renderer));
+          break;
+        }
+        case "text": {
+          const textToken = token;
+          out += renderer.text(textToken.text);
+          break;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+var _Hooks = class {
+  options;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set([
+    "preprocess",
+    "postprocess",
+    "processAllTokens"
+  ]);
+  /**
+   * Process markdown before marked
+   */
+  preprocess(markdown) {
+    return markdown;
+  }
+  /**
+   * Process HTML after marked is finished
+   */
+  postprocess(html2) {
+    return html2;
+  }
+  /**
+   * Process all tokens before walk tokens
+   */
+  processAllTokens(tokens) {
+    return tokens;
+  }
+};
+var Marked = class {
+  defaults = _getDefaults();
+  options = this.setOptions;
+  parse = this.#parseMarkdown(_Lexer.lex, _Parser.parse);
+  parseInline = this.#parseMarkdown(_Lexer.lexInline, _Parser.parseInline);
+  Parser = _Parser;
+  Renderer = _Renderer;
+  TextRenderer = _TextRenderer;
+  Lexer = _Lexer;
+  Tokenizer = _Tokenizer;
+  Hooks = _Hooks;
+  constructor(...args) {
+    this.use(...args);
+  }
+  /**
+   * Run callback for every token
+   */
+  walkTokens(tokens, callback) {
+    let values = [];
+    for (const token of tokens) {
+      values = values.concat(callback.call(this, token));
+      switch (token.type) {
+        case "table": {
+          const tableToken = token;
+          for (const cell of tableToken.header) {
+            values = values.concat(this.walkTokens(cell.tokens, callback));
+          }
+          for (const row of tableToken.rows) {
+            for (const cell of row) {
+              values = values.concat(this.walkTokens(cell.tokens, callback));
+            }
+          }
+          break;
+        }
+        case "list": {
+          const listToken = token;
+          values = values.concat(this.walkTokens(listToken.items, callback));
+          break;
+        }
+        default: {
+          const genericToken = token;
+          if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
+            this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+              const tokens2 = genericToken[childTokens].flat(Infinity);
+              values = values.concat(this.walkTokens(tokens2, callback));
+            });
+          } else if (genericToken.tokens) {
+            values = values.concat(this.walkTokens(genericToken.tokens, callback));
+          }
+        }
+      }
+    }
+    return values;
+  }
+  use(...args) {
+    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    args.forEach((pack) => {
+      const opts = { ...pack };
+      opts.async = this.defaults.async || opts.async || false;
+      if (pack.extensions) {
+        pack.extensions.forEach((ext) => {
+          if (!ext.name) {
+            throw new Error("extension name required");
+          }
+          if ("renderer" in ext) {
+            const prevRenderer = extensions.renderers[ext.name];
+            if (prevRenderer) {
+              extensions.renderers[ext.name] = function(...args2) {
+                let ret = ext.renderer.apply(this, args2);
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args2);
+                }
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
+            }
+          }
+          if ("tokenizer" in ext) {
+            if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
+              throw new Error("extension level must be 'block' or 'inline'");
+            }
+            const extLevel = extensions[ext.level];
+            if (extLevel) {
+              extLevel.unshift(ext.tokenizer);
+            } else {
+              extensions[ext.level] = [ext.tokenizer];
+            }
+            if (ext.start) {
+              if (ext.level === "block") {
+                if (extensions.startBlock) {
+                  extensions.startBlock.push(ext.start);
+                } else {
+                  extensions.startBlock = [ext.start];
+                }
+              } else if (ext.level === "inline") {
+                if (extensions.startInline) {
+                  extensions.startInline.push(ext.start);
+                } else {
+                  extensions.startInline = [ext.start];
+                }
+              }
+            }
+          }
+          if ("childTokens" in ext && ext.childTokens) {
+            extensions.childTokens[ext.name] = ext.childTokens;
+          }
+        });
+        opts.extensions = extensions;
+      }
+      if (pack.renderer) {
+        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
+        for (const prop in pack.renderer) {
+          if (!(prop in renderer)) {
+            throw new Error(`renderer '${prop}' does not exist`);
+          }
+          if (prop === "options") {
+            continue;
+          }
+          const rendererProp = prop;
+          const rendererFunc = pack.renderer[rendererProp];
+          const prevRenderer = renderer[rendererProp];
+          renderer[rendererProp] = (...args2) => {
+            let ret = rendererFunc.apply(renderer, args2);
+            if (ret === false) {
+              ret = prevRenderer.apply(renderer, args2);
+            }
+            return ret || "";
+          };
+        }
+        opts.renderer = renderer;
+      }
+      if (pack.tokenizer) {
+        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+        for (const prop in pack.tokenizer) {
+          if (!(prop in tokenizer)) {
+            throw new Error(`tokenizer '${prop}' does not exist`);
+          }
+          if (["options", "rules", "lexer"].includes(prop)) {
+            continue;
+          }
+          const tokenizerProp = prop;
+          const tokenizerFunc = pack.tokenizer[tokenizerProp];
+          const prevTokenizer = tokenizer[tokenizerProp];
+          tokenizer[tokenizerProp] = (...args2) => {
+            let ret = tokenizerFunc.apply(tokenizer, args2);
+            if (ret === false) {
+              ret = prevTokenizer.apply(tokenizer, args2);
+            }
+            return ret;
+          };
+        }
+        opts.tokenizer = tokenizer;
+      }
+      if (pack.hooks) {
+        const hooks = this.defaults.hooks || new _Hooks();
+        for (const prop in pack.hooks) {
+          if (!(prop in hooks)) {
+            throw new Error(`hook '${prop}' does not exist`);
+          }
+          if (prop === "options") {
+            continue;
+          }
+          const hooksProp = prop;
+          const hooksFunc = pack.hooks[hooksProp];
+          const prevHook = hooks[hooksProp];
+          if (_Hooks.passThroughHooks.has(prop)) {
+            hooks[hooksProp] = (arg) => {
+              if (this.defaults.async) {
+                return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
+                  return prevHook.call(hooks, ret2);
+                });
+              }
+              const ret = hooksFunc.call(hooks, arg);
+              return prevHook.call(hooks, ret);
+            };
+          } else {
+            hooks[hooksProp] = (...args2) => {
+              let ret = hooksFunc.apply(hooks, args2);
+              if (ret === false) {
+                ret = prevHook.apply(hooks, args2);
+              }
+              return ret;
+            };
+          }
+        }
+        opts.hooks = hooks;
+      }
+      if (pack.walkTokens) {
+        const walkTokens2 = this.defaults.walkTokens;
+        const packWalktokens = pack.walkTokens;
+        opts.walkTokens = function(token) {
+          let values = [];
+          values.push(packWalktokens.call(this, token));
+          if (walkTokens2) {
+            values = values.concat(walkTokens2.call(this, token));
+          }
+          return values;
+        };
+      }
+      this.defaults = { ...this.defaults, ...opts };
+    });
+    return this;
+  }
+  setOptions(opt) {
+    this.defaults = { ...this.defaults, ...opt };
+    return this;
+  }
+  lexer(src, options2) {
+    return _Lexer.lex(src, options2 ?? this.defaults);
+  }
+  parser(tokens, options2) {
+    return _Parser.parse(tokens, options2 ?? this.defaults);
+  }
+  #parseMarkdown(lexer2, parser2) {
+    return (src, options2) => {
+      const origOpt = { ...options2 };
+      const opt = { ...this.defaults, ...origOpt };
+      if (this.defaults.async === true && origOpt.async === false) {
+        if (!opt.silent) {
+          console.warn("marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored.");
+        }
+        opt.async = true;
+      }
+      const throwError = this.#onError(!!opt.silent, !!opt.async);
+      if (typeof src === "undefined" || src === null) {
+        return throwError(new Error("marked(): input parameter is undefined or null"));
+      }
+      if (typeof src !== "string") {
+        return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
+      }
+      if (opt.hooks) {
+        opt.hooks.options = opt;
+      }
+      if (opt.async) {
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer2(src2, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html2) => opt.hooks ? opt.hooks.postprocess(html2) : html2).catch(throwError);
+      }
+      try {
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        let tokens = lexer2(src, opt);
+        if (opt.hooks) {
+          tokens = opt.hooks.processAllTokens(tokens);
+        }
+        if (opt.walkTokens) {
+          this.walkTokens(tokens, opt.walkTokens);
+        }
+        let html2 = parser2(tokens, opt);
+        if (opt.hooks) {
+          html2 = opt.hooks.postprocess(html2);
+        }
+        return html2;
+      } catch (e) {
+        return throwError(e);
+      }
+    };
+  }
+  #onError(silent, async) {
+    return (e) => {
+      e.message += "\nPlease report this to https://github.com/markedjs/marked.";
+      if (silent) {
+        const msg = "<p>An error occurred:</p><pre>" + escape$1(e.message + "", true) + "</pre>";
+        if (async) {
+          return Promise.resolve(msg);
+        }
+        return msg;
+      }
+      if (async) {
+        return Promise.reject(e);
+      }
+      throw e;
+    };
+  }
+};
+var markedInstance = new Marked();
+function marked(src, opt) {
+  return markedInstance.parse(src, opt);
+}
+marked.options = marked.setOptions = function(options2) {
+  markedInstance.setOptions(options2);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.getDefaults = _getDefaults;
+marked.defaults = _defaults;
+marked.use = function(...args) {
+  markedInstance.use(...args);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.walkTokens = function(tokens, callback) {
+  return markedInstance.walkTokens(tokens, callback);
+};
+marked.parseInline = markedInstance.parseInline;
+marked.Parser = _Parser;
+marked.parser = _Parser.parse;
+marked.Renderer = _Renderer;
+marked.TextRenderer = _TextRenderer;
+marked.Lexer = _Lexer;
+marked.lexer = _Lexer.lex;
+marked.Tokenizer = _Tokenizer;
+marked.Hooks = _Hooks;
+marked.parse = marked;
+var options = marked.options;
+var setOptions = marked.setOptions;
+var use = marked.use;
+var walkTokens = marked.walkTokens;
+var parseInline = marked.parseInline;
+var parser = _Parser.parse;
+var lexer = _Lexer.lex;
+
+// app/assets/javascripts/llm_meta_widget/config.js
+var DEFAULTS = Object.freeze({
+  API_KEY_UUID: "ollama-local",
+  ACTIONS_SCHEMA_ID: "ai-actions",
+  STATE_GLOBAL: "aiState",
+  ACTIONS_GLOBAL: "aiActions",
+  REMOTE_TOOLS_SCHEMA_ID: "remote-mcp-tools",
+  LLM_PROVIDER: "llm_meta_server",
+  MAX_ROUNDS: 3
+});
+var splitList = (v) => v.split(",").map((s) => s.trim()).filter(Boolean);
+function readConfig(el) {
+  const raw = (n) => el && el.hasAttribute(n) ? el.getAttribute(n) : null;
+  const str = (n, d) => {
+    const v = raw(n);
+    return v === null ? d : v;
+  };
+  const bool = (n, d) => {
+    const v = raw(n);
+    return v === null ? d : v !== "false";
+  };
+  const int = (n, d) => {
+    const v = raw(n);
+    if (v === null) return d;
+    const i = parseInt(v, 10);
+    return Number.isNaN(i) ? d : i;
+  };
+  const list2 = (n) => {
+    const v = raw(n);
+    return v === null || v.trim() === "" ? null : splitList(v);
+  };
+  const toolHub = str("tool-hub-url", null) || null;
+  const wellKnown = raw("well-known-urls");
+  return {
+    LLM_BASE: str("llm-url", null),
+    TOOL_HUB_BASE: toolHub,
+    API_KEY_UUID: str("api-key-uuid", DEFAULTS.API_KEY_UUID),
+    MODEL: str("model", null),
+    ACTIONS_SCHEMA_ID: str("actions-schema-id", DEFAULTS.ACTIONS_SCHEMA_ID),
+    GREETING: str("greeting", null),
+    STATE_GLOBAL: str("state-global", DEFAULTS.STATE_GLOBAL),
+    ACTIONS_GLOBAL: str("actions-global", DEFAULTS.ACTIONS_GLOBAL),
+    REMOTE_TOOLS_SCHEMA_ID: str("remote-tools-schema-id", DEFAULTS.REMOTE_TOOLS_SCHEMA_ID),
+    MAX_ROUNDS: int("max-rounds", DEFAULTS.MAX_ROUNDS),
+    WELL_KNOWN_URLS: wellKnown === null ? null : wellKnown.trim() === "" ? [] : splitList(wellKnown),
+    LLM_PROVIDER: str("llm-provider", DEFAULTS.LLM_PROVIDER),
+    ENABLE_MODEL_PICKER: bool("enable-model-picker", true),
+    // Class 1 tools are registered on a hub, so the picker needs one — which is
+    // independent of who answers the chat. Page actions and the host's own
+    // .well-known MCP work regardless.
+    ENABLE_TOOL_PICKER: bool("enable-tool-picker", true) && toolHub !== null,
+    MODEL_ALLOWLIST: list2("models"),
+    HUB_TOOLS_ALLOWLIST: list2("hub-tools")
+  };
+}
+
+// app/assets/stylesheets/llm_meta_widget/conversation.css
+var conversation_default = `/*
+ * Canonical "chat conversation" styles for the llm_meta ecosystem.
+ *
+ * Owned by the llm_meta_widget gem. Consumed by:
+ *   - the widget partial itself (llm_meta_widget/_chat_panel.html.erb)
+ *   - any llm_meta_client-scaffolded chat host that adopts the same
+ *     conversation surface
+ *
+ * Scoped by the \`.llm-meta-conversation\` opt-in class on a wrapping
+ * element \u2014 so these rules only affect elements the consumer has
+ * declared as chat-conversation surfaces. Prevents accidental style
+ * bleed onto random host-page elements named .message or .message-role.
+ *
+ * Any host that wants the styles applied wraps its conversation
+ * markup in <div class="llm-meta-conversation"> ... </div> and includes
+ * this file (served via /llm_meta_widget_assets/conversation.css).
+ */
+
+.llm-meta-conversation .message {
+	position: relative;
+	margin-bottom: 6px;
+	padding: 6px 10px;
+	border-radius: 8px;
+	max-width: 85%;
+	line-height: 1.4;
+	word-wrap: break-word;
+}
+.llm-meta-conversation .message.user {
+	background-color: #dbeafe;
+	border: 1px solid #bfdbfe;
+	margin-left: auto;
+}
+.llm-meta-conversation .message.assistant {
+	background-color: #ffffff;
+	border: 1px solid #e5e7eb;
+	margin-right: auto;
+}
+.llm-meta-conversation .message.system {
+	background-color: #fef3c7;
+	border: 1px solid #fde68a;
+	color: #78350f;
+	font-size: 0.9em;
+	font-style: italic;
+}
+.llm-meta-conversation .message.error {
+	background-color: #fee2e2;
+	border: 1px solid #fecaca;
+	color: #991b1b;
+}
+
+.llm-meta-conversation .message-role {
+	display: block;
+	font-weight: 600;
+	font-size: 13px;
+	color: #374151;
+	margin-bottom: 4px;
+}
+.llm-meta-conversation .message-content {
+	line-height: 1.4;
+	word-wrap: break-word;
+	overflow-wrap: anywhere;
+	min-width: 0;
+	color: #1f2937;
+}
+
+/* Markdown-rendered content styling \u2014 matches llm_meta_chat's
+ * .message-content descendants in chats.css so LLM output looks the
+ * same wherever it renders (widget's streaming path uses marked.esm.js;
+ * chat host's saved-message path uses Redcarpet server-side; both
+ * produce standard HTML that these rules style). */
+.llm-meta-conversation .message-content p { margin: 0 0 0.5em 0; }
+.llm-meta-conversation .message-content p:last-child { margin-bottom: 0; }
+.llm-meta-conversation .message-content h1,
+.llm-meta-conversation .message-content h2,
+.llm-meta-conversation .message-content h3,
+.llm-meta-conversation .message-content h4,
+.llm-meta-conversation .message-content h5,
+.llm-meta-conversation .message-content h6 {
+	margin: 0.5em 0 0.25em 0;
+	line-height: 1.25;
+}
+.llm-meta-conversation .message-content ul,
+.llm-meta-conversation .message-content ol {
+	margin: 0.25em 0 0.5em 1.25em;
+	padding: 0;
+}
+.llm-meta-conversation .message-content li { margin: 0.1em 0; }
+.llm-meta-conversation .message-content blockquote {
+	border-left: 3px solid #d1d5db;
+	margin: 0.5em 0;
+	padding: 0.1em 0.75em;
+	color: #4b5563;
+}
+.llm-meta-conversation .message-content code {
+	background-color: #f3f4f6;
+	padding: 1px 4px;
+	border-radius: 4px;
+	font-size: 0.9em;
+	font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+.llm-meta-conversation .message-content pre {
+	background-color: #f3f4f6;
+	border: 1px solid #e5e7eb;
+	border-radius: 6px;
+	padding: 8px 10px;
+	margin: 0.5em 0;
+	overflow-x: auto;
+	max-width: 100%;
+	white-space: pre;
+}
+.llm-meta-conversation .message-content pre code { background: none; padding: 0; }
+.llm-meta-conversation .message-content table {
+	border-collapse: collapse;
+	margin: 0.5em 0;
+	display: block;
+	overflow-x: auto;
+	max-width: 100%;
+}
+.llm-meta-conversation .message-content th,
+.llm-meta-conversation .message-content td {
+	border: 1px solid #d1d5db;
+	padding: 4px 8px;
+}
+.llm-meta-conversation .message-content th { background-color: #f3f4f6; }
+.llm-meta-conversation .message-content a {
+	color: #2563eb;
+	text-decoration: underline;
+}
+.llm-meta-conversation .message-content img { max-width: 100%; height: auto; }
+
+/* Tool-use footer inside an assistant bubble \u2014 compact chips naming the
+ * tools the LLM invoked this turn. Gives users visual confirmation of
+ * what actually happened, particularly when the LLM's own text is thin. */
+.llm-meta-conversation .lmw-tool-chips {
+	margin-top: 0.5em;
+	padding-top: 0.5em;
+	border-top: 1px dashed #e5e7eb;
+	display: flex; flex-wrap: wrap; gap: 4px;
+}
+.llm-meta-conversation .lmw-tool-chip {
+	display: inline-block;
+	padding: 2px 8px;
+	background: #eef2ff;
+	color: #3730a3;
+	border: 1px solid #c7d2fe;
+	border-radius: 10px;
+	font-size: 0.8em;
+	font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+	line-height: 1.4;
+}
+.llm-meta-conversation .lmw-tool-chip.error {
+	background: #fee2e2;
+	color: #991b1b;
+	border-color: #fecaca;
+}
+
+/* Thinking-token collapsible block \u2014 same shape as llm_meta_chat's
+ * .message-thinking. Streams during reasoning, collapses to a
+ * "(finished)" summary once text starts flowing. */
+.llm-meta-conversation .message-thinking {
+	margin: 0.5em 0;
+	padding: 0.5em 0.75em;
+	background: #f3f4f6;
+	border-left: 3px solid #9ca3af;
+	border-radius: 4px;
+	font-size: 0.85em;
+}
+.llm-meta-conversation .message-thinking summary {
+	cursor: pointer;
+	color: #6b7280;
+	font-weight: 500;
+	user-select: none;
+}
+.llm-meta-conversation .message-thinking-content {
+	margin-top: 0.5em;
+	color: #4b5563;
+	white-space: pre-wrap;
+	font-family: ui-monospace, "SF Mono", monospace;
+	font-size: 0.9em;
+	line-height: 1.5;
+	max-height: 10em;
+	overflow-y: auto;
+}
+
+/* ---- "working" signals, ported from llm_meta_chat's chats.css ------------
+ *
+ * The wait is often long on local models \u2014 a tool round re-processes the
+ * whole prompt plus the tool results before the first token \u2014 so a still
+ * label reads as a hang. Same class names as the chat app, so the two
+ * surfaces behave identically. */
+.message-role .role-spinner {
+  display: inline-block;
+  animation: role-working-spin 1.8s linear infinite;
+  transform-origin: 50% 50%;
+}
+
+@keyframes role-working-spin {
+  from { transform: rotate(0deg); }
+  to   { transform: rotate(360deg); }
+}
+
+/* Staggered three-dot indicator on the reasoning summary while thinking is
+ * still streaming. Hidden unless .thinking-active is present. */
+.thinking-dots {
+  display: none;
+  margin-left: 0.35em;
+  letter-spacing: 0.15em;
+  font-weight: bold;
+}
+
+.message-thinking.thinking-active .thinking-dots { display: inline-block; }
+
+.message-thinking.thinking-active .thinking-dots span {
+  display: inline-block;
+  opacity: 0.25;
+  animation: thinking-dot 1.4s ease-in-out infinite;
+}
+
+.message-thinking.thinking-active .thinking-dots span:nth-child(2) { animation-delay: 0.2s; }
+.message-thinking.thinking-active .thinking-dots span:nth-child(3) { animation-delay: 0.4s; }
+
+@keyframes thinking-dot {
+  0%, 60%, 100% { opacity: 0.25; }
+  30%           { opacity: 1; }
+}
+
+/* Respect a reader's motion preference: keep the label, drop the movement. */
+@media (prefers-reduced-motion: reduce) {
+  .message-role .role-spinner,
+  .message-thinking.thinking-active .thinking-dots span { animation: none; }
+}
+`;
+
+// app/assets/stylesheets/llm_meta_widget/panel.css
+var panel_default = `/* The chat panel's own styles. Extracted from _chat_panel.html.erb when the
+   panel became a custom element; bundled into the element so a non-Rails host
+   serves no stylesheet of its own. Conversation-surface styles (bubbles, role
+   labels, thinking blocks) stay in conversation.css. */
+	/* Widget-specific chrome \u2014 floating container, header, scroll region,
+	 * input area. Everything BUBBLE / THINKING / ROLE-related lives in the
+	 * shared conversation.css above. */
+	#llm-meta-widget-chat {
+		/* Positioned via JS on open (see setOpen()) so top/left are set in
+		 * pixels \u2014 required for CSS \`resize: both\` to grow correctly
+		 * (bottom/right anchoring blocks the resize handle from being
+		 * dragged outward from viewport corner). */
+		position: fixed;
+		width: 40em; height: 55vh;
+		min-width: 24em; min-height: 16em;
+		max-width: calc(100vw - 2em); max-height: calc(100vh - 2em);
+		background: #ffffff;
+		border: 1px solid #e5e7eb;
+		border-radius: 8px;
+		box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+		padding: 10px;
+		z-index: 9999;
+		font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+		font-size: 14px;
+		color: #1f2937;
+		display: flex; flex-direction: column;
+		/* Native drag-to-resize handle appears at bottom-right when
+		 * overflow != visible. overflow:hidden clips at widget edge; the
+		 * inner .lmw-messages has its own scroll so no content is lost. */
+		resize: both;
+		overflow: hidden;
+	}
+	#llm-meta-widget-chat.lmw-collapsed { display: none; }
+
+	/* Collapsed-state toggle \u2014 a small floating chat-bubble button in the
+	 * bottom-right corner. Always in the DOM; visible only when the chat
+	 * panel is collapsed. Click to open the chat panel; the panel's \xD7 button
+	 * collapses back to this. State persists across page loads via
+	 * localStorage (see the JS below). */
+	#llm-meta-widget-toggle {
+		position: fixed; bottom: 1em; right: 1em;
+		width: 52px; height: 52px;
+		border-radius: 26px;
+		background-color: #3b82f6;
+		color: white;
+		border: none;
+		box-shadow: 0 4px 12px rgba(0, 0, 0, 0.18);
+		cursor: pointer;
+		z-index: 9999;
+		display: flex; align-items: center; justify-content: center;
+		transition: background-color 0.15s, transform 0.1s;
+	}
+	#llm-meta-widget-toggle:hover { background-color: #2563eb; }
+	#llm-meta-widget-toggle:active { transform: scale(0.96); }
+	#llm-meta-widget-toggle.lmw-hidden { display: none; }
+	#llm-meta-widget-toggle svg { display: block; }
+
+	/* Header hide/close: a subtle "\u2212" button that collapses to the toggle
+	 * bubble. Sits between the "clear" button and title. */
+	#llm-meta-widget-chat .lmw-hide {
+		background: none; border: none;
+		color: #6b7280;
+		font: inherit; font-size: 18px; line-height: 1;
+		cursor: pointer;
+		padding: 0 8px;
+		transition: color 0.15s;
+	}
+	#llm-meta-widget-chat .lmw-hide:hover { color: #1f2937; }
+	#llm-meta-widget-chat .lmw-header {
+		display: flex; justify-content: space-between; align-items: center;
+		gap: 8px;
+		padding-bottom: 8px; margin-bottom: 8px;
+		border-bottom: 2px solid #e5e7eb;
+	}
+	#llm-meta-widget-chat .lmw-header-right { display: flex; align-items: center; gap: 4px; flex-shrink: 0; }
+
+	/* Level-1 pickers row \u2014 matches chat.aibranch.org's input-container
+	 * convention (attach / model / tools / settings in a horizontal row
+	 * below the textarea). We only render model + tools for now. Uses
+	 * relative positioning so the tools <details> panel can drop down
+	 * as a floating overlay instead of pushing the input area around. */
+	#llm-meta-widget-chat .lmw-input-controls {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		margin-top: 6px;
+		position: relative;
+		min-height: 26px;
+	}
+	#llm-meta-widget-chat .lmw-title { font-weight: 600; color: #1f2937; }
+
+	/* Level-1 model picker \u2014 compact <select> next to the title.
+	 * Populated by JS on widget open from GET /api/llms (anon path
+	 * returns Ollama-only). Hidden entirely if enable_model_picker
+	 * is false at the helper call site. */
+	#llm-meta-widget-chat .lmw-model-picker {
+		font: inherit; font-size: 12px;
+		padding: 3px 6px;
+		border: 1px solid #d1d5db;
+		border-radius: 4px;
+		background: #f9fafb;
+		color: #374151;
+		cursor: pointer;
+		max-width: 12em;
+		text-overflow: ellipsis;
+	}
+	#llm-meta-widget-chat .lmw-model-picker:focus {
+		outline: none;
+		border-color: #3b82f6;
+		box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.15);
+	}
+
+	/* Level-1 tools picker \u2014 inline chip in the input-controls row (same
+	 * convention as chat.aibranch.org). The tools list drops down as a
+	 * floating overlay above the input, so opening the panel doesn't
+	 * push the textarea around. Populated by JS on widget open from
+	 * GET /api/mcp_servers (anon path returns public_to_anonymous MCP
+	 * servers with their tools inline). One checkbox per SERVER \u2014
+	 * toggling enables/disables ALL of its tools. */
+	#llm-meta-widget-chat .lmw-tools-picker {
+		position: relative;   /* anchor for the absolutely-positioned list */
+	}
+	#llm-meta-widget-chat .lmw-tools-picker > summary {
+		list-style: none;
+		cursor: pointer;
+		padding: 3px 8px;
+		font-size: 12px;
+		color: #374151;
+		background: #f9fafb;
+		border: 1px solid #d1d5db;
+		border-radius: 4px;
+		display: inline-flex; align-items: center; gap: 6px;
+	}
+	#llm-meta-widget-chat .lmw-tools-picker > summary:hover { background: #f3f4f6; }
+	#llm-meta-widget-chat .lmw-tools-picker > summary::-webkit-details-marker { display: none; }
+	#llm-meta-widget-chat .lmw-tools-picker[open] > summary {
+		background: #eff6ff;
+		border-color: #93c5fd;
+	}
+	#llm-meta-widget-chat .lmw-tools-count {
+		display: inline-block;
+		background: #0ea5e9;
+		color: #fff;
+		font-size: 10px;
+		padding: 0 5px;
+		border-radius: 8px;
+		min-width: 14px;
+		text-align: center;
+	}
+	#llm-meta-widget-chat .lmw-tools-count.lmw-tools-count-zero {
+		background: #d1d5db;
+		color: #6b7280;
+	}
+	/* Floating dropdown panel \u2014 sits above the input area when open so
+	 * expanding never shifts the textarea. Bottom-anchored so it opens
+	 * UPWARD (natural direction since we're at the panel's bottom). */
+	#llm-meta-widget-chat .lmw-tools-list {
+		position: absolute;
+		bottom: calc(100% + 4px);
+		left: 0;
+		min-width: 220px;
+		max-height: 12em;
+		overflow-y: auto;
+		background: #ffffff;
+		border: 1px solid #d1d5db;
+		border-radius: 6px;
+		box-shadow: 0 4px 12px rgba(0, 0, 0, 0.10);
+		padding: 4px 0;
+		z-index: 10;
+	}
+	#llm-meta-widget-chat .lmw-tools-item {
+		display: flex; align-items: center; gap: 6px;
+		padding: 4px 10px;
+		font-size: 12px;
+		color: #374151;
+		cursor: pointer;
+	}
+	#llm-meta-widget-chat .lmw-tools-item:hover { background: #eff6ff; }
+	#llm-meta-widget-chat .lmw-tools-item input[type="checkbox"] { margin: 0; }
+	#llm-meta-widget-chat .lmw-tools-empty {
+		padding: 6px 10px;
+		font-size: 12px;
+		color: #94a3b8;
+		font-style: italic;
+	}
+	/* Two-level tool selection \u2014 mirrors chat.aibranch.org's tool_selector.
+	 * Server row (bulk checkbox + name + count + caret) is clickable to
+	 * expand its children. Individual tool rows are indented one level. */
+	#llm-meta-widget-chat .lmw-tools-server + .lmw-tools-server {
+		border-top: 1px solid #f1f5f9;
+	}
+	#llm-meta-widget-chat .lmw-tools-server-row {
+		display: flex; align-items: center; gap: 6px;
+		padding: 4px 10px;
+		font-size: 12px;
+		font-weight: 500;
+		color: #1f2937;
+		cursor: pointer;
+	}
+	#llm-meta-widget-chat .lmw-tools-server-row:hover { background: #eff6ff; }
+	#llm-meta-widget-chat .lmw-tools-server-name  { flex: 1; }
+	#llm-meta-widget-chat .lmw-tools-server-caret {
+		color: #94a3b8;
+		font-size: 10px;
+		line-height: 1;
+		flex-shrink: 0;
+	}
+	#llm-meta-widget-chat .lmw-tools-item-child {
+		padding-left: 26px;  /* align tool checkboxes past the server bulk checkbox */
+		font-size: 12px;
+		color: #4b5563;
+	}
+	#llm-meta-widget-chat .lmw-clear {
+		background: #ef4444; color: white; border: none;
+		padding: 4px 10px; border-radius: 6px; cursor: pointer;
+		font: inherit; font-size: 12px;
+		transition: background-color 0.15s;
+	}
+	#llm-meta-widget-chat .lmw-clear:hover { background: #dc2626; }
+
+	#llm-meta-widget-chat .lmw-messages {
+		flex: 1; overflow-y: auto;
+		padding: 10px;
+		background-color: #f9fafb;
+		border-radius: 8px;
+		margin-bottom: 8px;
+		min-height: 6em;
+		/* No max-height \u2014 messages grows with the widget (which the user
+		 * can drag to any size). A hard cap here would leave an ugly gap
+		 * between the messages area and the input on tall widget sizes. */
+	}
+	#llm-meta-widget-chat .lmw-messages::-webkit-scrollbar { width: 8px; }
+	#llm-meta-widget-chat .lmw-messages::-webkit-scrollbar-track { background: #f1f1f1; border-radius: 4px; }
+	#llm-meta-widget-chat .lmw-messages::-webkit-scrollbar-thumb { background: #cbd5e1; border-radius: 4px; }
+	#llm-meta-widget-chat .lmw-messages::-webkit-scrollbar-thumb:hover { background: #94a3b8; }
+
+	/* Input area \u2014 mirrors llm_meta_chat's .chat-input-container +
+	 * .chat-input + .send-button so it reads as the same UI. Multi-line
+	 * textarea with an absolutely-positioned paper-plane send button
+	 * (SVG inlined so no external icon-font dep). */
+	#llm-meta-widget-chat .lmw-input-container {
+		background-color: white;
+		border: 2px solid #e5e7eb;
+		border-radius: 8px;
+		padding: 8px;
+	}
+	#llm-meta-widget-chat .message-content details > summary {
+		cursor: pointer;
+		font-weight: 600;
+	}
+	#llm-meta-widget-chat .lmw-sent-text {
+		margin-top: 6px;
+		font-size: 12px;
+		opacity: 0.8;
+		white-space: pre-wrap;
+	}
+
+	/* Opening state: greeting + the offers themselves. Shown until the first
+	 * real turn, and again after Clear. */
+	#llm-meta-widget-chat .lmw-welcome { padding: 4px 2px 2px; }
+	#llm-meta-widget-chat .lmw-welcome-hello {
+		margin: 0 0 12px;
+		font-size: 14px;
+		line-height: 1.5;
+		color: #374151;
+	}
+	#llm-meta-widget-chat .lmw-welcome-card {
+		background-color: #f9fafb;
+		border: 1px solid #e5e7eb;
+		border-radius: 8px;
+		padding: 10px 12px;
+		margin-bottom: 8px;
+	}
+	#llm-meta-widget-chat .lmw-welcome-start {
+		background-color: #eff6ff;
+		color: #1d4ed8;
+		border: 1px solid #bfdbfe;
+		border-radius: 999px;
+		padding: 4px 12px;
+		font-size: 13px;
+		font-family: inherit;
+		cursor: pointer;
+	}
+	#llm-meta-widget-chat .lmw-welcome-start:hover { background-color: #dbeafe; }
+	#llm-meta-widget-chat .lmw-welcome-why {
+		margin: 8px 0 0;
+		font-size: 13px;
+		line-height: 1.45;
+		color: #4b5563;
+	}
+	#llm-meta-widget-chat .lmw-welcome-slots {
+		margin: 8px 0 0;
+		padding-left: 16px;
+		font-size: 12px;
+		color: #6b7280;
+	}
+	#llm-meta-widget-chat .lmw-welcome-slots li { margin-bottom: 2px; }
+	#llm-meta-widget-chat .lmw-welcome-slots li.filled { color: #047857; }
+
+	/* 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 {
+		width: 100%;
+		padding: 10px 48px 10px 10px;
+		border: 1px solid #d1d5db;
+		border-radius: 6px;
+		font-size: 14px;
+		font-family: inherit;
+		resize: vertical;
+		min-height: 44px;
+		box-sizing: border-box;
+		transition: border-color 0.2s, box-shadow 0.2s;
+	}
+	#llm-meta-widget-chat .lmw-input:focus {
+		outline: none;
+		border-color: #3b82f6;
+		box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+	}
+	#llm-meta-widget-chat .lmw-send {
+		position: absolute;
+		bottom: 6px;
+		right: 6px;
+		background-color: #3b82f6;
+		color: white;
+		border: none;
+		width: 32px;
+		height: 32px;
+		padding: 0;
+		border-radius: 6px;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		transition: background-color 0.15s, opacity 0.15s;
+	}
+	#llm-meta-widget-chat .lmw-send:hover { background-color: #2563eb; }
+	#llm-meta-widget-chat .lmw-send:disabled { opacity: 0.5; cursor: not-allowed; }
+	#llm-meta-widget-chat .lmw-send svg { display: block; }
+`;
+
+// app/assets/javascripts/llm_meta_widget/element.js
+marked.setOptions({ gfm: true, breaks: true });
+var MARKUP = `
+<button type="button" id="llm-meta-widget-toggle" title="Open AI assistant" aria-label="Open AI assistant">
+	<svg xmlns="http://www.w3.org/2000/svg" width="22" height="22" fill="currentColor" viewBox="0 0 16 16" aria-hidden="true">
+		<path d="M2 4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2h-3l-3.5 3.5V12H4a2 2 0 0 1-2-2V4Zm3 2a1 1 0 1 0 0 2 1 1 0 0 0 0-2Zm3 0a1 1 0 1 0 0 2 1 1 0 0 0 0-2Zm3 0a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z"/>
+	</svg>
+</button>
+
+<div id="llm-meta-widget-chat" class="llm-meta-conversation">
+	<div class="lmw-header">
+		<span class="lmw-title">AI assistant</span>
+		<div class="lmw-header-right">
+			<button type="button" class="lmw-clear" title="Clear conversation">clear</button>
+			<button type="button" class="lmw-hide" title="Hide">\u2212</button>
+		</div>
+	</div>
+	<div class="lmw-messages"></div>
+	<div class="lmw-input-container">
+		    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>
+				<button type="submit" class="lmw-send" title="Send message">
+					<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" viewBox="0 0 16 16" aria-hidden="true">
+						<path d="M15.964.686a.5.5 0 0 0-.65-.65L.293 6.011a.513.513 0 0 0 .002.947l4.708 1.878 8.94-6.94-6.94 8.94 1.879 4.708c.163.407.756.416.951.016l6.13-13.884Z"/>
+					</svg>
+				</button>
+			</div>
+			<% if enable_model_picker || enable_tool_picker %>
+				<div class="lmw-input-controls">
+					<% if enable_model_picker %>
+						<select class="lmw-model-picker" title="Select model" aria-label="Select model" style="display:none">
+						</select>
+					<% end %>
+					<% if enable_tool_picker %>
+						<details class="lmw-tools-picker">
+							<summary>
+								\u{1F527} Tools
+								<span class="lmw-tools-count lmw-tools-count-zero">0</span>
+							</summary>
+							<div class="lmw-tools-list">
+								<div class="lmw-tools-empty">Loading\u2026</div>
+							</div>
+						</details>
+					<% end %>
+				</div>
+			<% end %>
+		</form>
+	</div>
+</div>
+`;
+var stylesInjected = false;
+function injectStylesOnce(doc) {
+  if (stylesInjected) return;
+  stylesInjected = true;
+  const style = doc.createElement("style");
+  style.setAttribute("data-llm-meta-widget", "styles");
+  style.textContent = conversation_default + "\n" + panel_default;
+  doc.head.appendChild(style);
+}
+var LlmMetaWidgetElement = class extends HTMLElement {
+  connectedCallback() {
+    if (this.__lmwWired) return;
+    this.__lmwWired = true;
+    if (!this.getAttribute("llm-url") || !this.getAttribute("model")) {
+      console.error("[llm-meta-widget] llm-url and model are both required attributes; not starting.");
+      return;
+    }
+    if (document.getElementById("llm-meta-widget-chat")) {
+      console.warn("[llm-meta-widget] a widget is already on this page; ignoring this one.");
+      return;
+    }
+    injectStylesOnce(document);
+    this.insertAdjacentHTML("beforeend", MARKUP);
+    boot(readConfig(this));
+  }
+};
+if (typeof customElements !== "undefined" && !customElements.get("llm-meta-widget")) {
+  customElements.define("llm-meta-widget", LlmMetaWidgetElement);
+}
+function boot(cfg) {
+  var LLM_BASE = cfg.LLM_BASE;
+  var TOOL_HUB_BASE = cfg.TOOL_HUB_BASE;
+  var API_KEY_UUID = cfg.API_KEY_UUID;
+  var MODEL = cfg.MODEL;
+  var ACTIONS_SCHEMA_ID = cfg.ACTIONS_SCHEMA_ID;
+  var GREETING = cfg.GREETING;
+  var STATE_GLOBAL = cfg.STATE_GLOBAL;
+  var ACTIONS_GLOBAL = cfg.ACTIONS_GLOBAL;
+  var REMOTE_TOOLS_SCHEMA_ID = cfg.REMOTE_TOOLS_SCHEMA_ID;
+  var MAX_ROUNDS = cfg.MAX_ROUNDS;
+  var WELL_KNOWN_URLS = cfg.WELL_KNOWN_URLS;
+  var LLM_PROVIDER = cfg.LLM_PROVIDER;
+  var ENABLE_MODEL_PICKER = cfg.ENABLE_MODEL_PICKER;
+  var ENABLE_TOOL_PICKER = cfg.ENABLE_TOOL_PICKER;
+  var MODEL_ALLOWLIST = cfg.MODEL_ALLOWLIST;
+  var HUB_TOOLS_ALLOWLIST = cfg.HUB_TOOLS_ALLOWLIST;
+  var root = document.getElementById("llm-meta-widget-chat");
+  var toggleBtn = document.getElementById("llm-meta-widget-toggle");
+  var historyEl = root.querySelector(".lmw-messages");
+  var formEl = root.querySelector(".lmw-form");
+  var inputEl = root.querySelector(".lmw-input");
+  var clearBtn = root.querySelector(".lmw-clear");
+  var hideBtn = root.querySelector(".lmw-hide");
+  var modelPicker = root.querySelector(".lmw-model-picker");
+  var toolsPicker = root.querySelector(".lmw-tools-picker");
+  var toolsListEl = root.querySelector(".lmw-tools-list");
+  var toolsCountEl = root.querySelector(".lmw-tools-count");
+  var STORAGE_KEY_OPEN = "llm_meta_widget:open";
+  var STORAGE_KEY_SIZE = "llm_meta_widget:size";
+  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 (!plausibleSize(w, h)) {
+        localStorage.removeItem(STORAGE_KEY_SIZE);
+        return;
+      }
+      root.style.width = w + "px";
+      root.style.height = h + "px";
+    } catch (e) {
+    }
+  }
+  function saveCurrentSize() {
+    try {
+      var rect = root.getBoundingClientRect();
+      var w = Math.round(rect.width), h = Math.round(rect.height);
+      if (!plausibleSize(w, h)) return;
+      localStorage.setItem(STORAGE_KEY_SIZE, w + "x" + h);
+    } catch (e) {
+    }
+  }
+  function positionAtBottomRight(attempt) {
+    var margin = 16;
+    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";
+    var tries = attempt || 0;
+    if (rect.height < MIN_SAVED_HEIGHT && tries < 3 && typeof requestAnimationFrame === "function") {
+      requestAnimationFrame(function() {
+        positionAtBottomRight(tries + 1);
+      });
+    }
+  }
+  function setOpen(open) {
+    if (open) {
+      applyStoredSize();
+      root.classList.remove("lmw-collapsed");
+      toggleBtn.classList.add("lmw-hidden");
+      positionAtBottomRight();
+      try {
+        inputEl.focus();
+      } catch (e) {
+      }
+      ensurePickerLoaded().catch(function(e) {
+        console.warn("[widget] picker load failed:", e);
+      });
+    } else {
+      saveCurrentSize();
+      root.classList.add("lmw-collapsed");
+      toggleBtn.classList.remove("lmw-hidden");
+    }
+    try {
+      localStorage.setItem(STORAGE_KEY_OPEN, open ? "1" : "0");
+    } catch (e) {
+    }
+  }
+  var initialOpen = false;
+  try {
+    initialOpen = localStorage.getItem(STORAGE_KEY_OPEN) === "1";
+  } catch (e) {
+  }
+  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);
+  });
+  if (typeof ResizeObserver === "function") {
+    var sawFirstResizeTick = false;
+    var ro = new ResizeObserver(function() {
+      if (root.classList.contains("lmw-collapsed")) return;
+      positionAtBottomRight();
+      if (!sawFirstResizeTick) {
+        sawFirstResizeTick = true;
+        return;
+      }
+      saveCurrentSize();
+    });
+    ro.observe(root);
+  }
+  var conversation = [];
+  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);
+  var remoteTools = remoteToolsEl ? JSON.parse(remoteToolsEl.textContent) : [];
+  var hubMcpServers = [];
+  var selectedToolIds = /* @__PURE__ */ new Set();
+  function anyAllowedByAllowlist(name, allowlist) {
+    return allowlist === null || allowlist.indexOf(name) >= 0;
+  }
+  function refreshRemoteToolsFromPicker() {
+    var flat = [];
+    hubMcpServers.forEach(function(s) {
+      (s.tools || []).forEach(function(t) {
+        if (!selectedToolIds.has(t.id)) return;
+        flat.push({
+          id: t.id,
+          name: t.name,
+          description: t.description,
+          input_schema: t.input_schema
+        });
+      });
+    });
+    remoteTools = flat;
+    if (toolsCountEl) {
+      toolsCountEl.textContent = flat.length;
+      toolsCountEl.classList.toggle("lmw-tools-count-zero", flat.length === 0);
+    }
+  }
+  function refreshServerBulkCheckbox(server, bulkCheckbox) {
+    var tools = server.tools || [];
+    var n = tools.length;
+    if (n === 0) {
+      bulkCheckbox.checked = false;
+      bulkCheckbox.indeterminate = false;
+      return;
+    }
+    var onCount = 0;
+    tools.forEach(function(t) {
+      if (selectedToolIds.has(t.id)) onCount++;
+    });
+    bulkCheckbox.checked = onCount === n;
+    bulkCheckbox.indeterminate = onCount > 0 && onCount < n;
+  }
+  async function loadHubResourcesForPickers() {
+    var tasks = [];
+    if (ENABLE_MODEL_PICKER && modelPicker && LLM_PROVIDER === "ollama") {
+      tasks.push(fetchOllamaModels({ baseUrl: LLM_BASE }).then(function(names) {
+        var flat = names.filter(function(n) {
+          return anyAllowedByAllowlist(n, MODEL_ALLOWLIST);
+        }).map(function(n) {
+          return { value: n, label: n };
+        });
+        if (!flat.some(function(m) {
+          return m.value === MODEL;
+        })) {
+          flat.unshift({ value: MODEL, label: MODEL });
+        }
+        modelPicker.innerHTML = "";
+        flat.forEach(function(m) {
+          var opt = document.createElement("option");
+          opt.value = m.value;
+          opt.textContent = m.label;
+          if (m.value === MODEL) opt.selected = true;
+          modelPicker.appendChild(opt);
+        });
+        if (flat.length > 1) modelPicker.style.display = "";
+      }));
+    } else if (ENABLE_MODEL_PICKER && modelPicker) {
+      tasks.push(fetch(LLM_BASE + "/api/llms", { headers: { "Accept": "application/json" } }).then(function(r) {
+        return r.ok ? r.json() : { llms: [] };
+      }).then(function(payload) {
+        var flat = [];
+        (payload.llms || []).forEach(function(llm) {
+          if (llm.family !== "ollama") return;
+          (llm.available_models || []).forEach(function(m) {
+            if (anyAllowedByAllowlist(m.value, MODEL_ALLOWLIST)) {
+              flat.push({ value: m.value, label: m.label });
+            }
+          });
+        });
+        if (!flat.some(function(m) {
+          return m.value === MODEL;
+        })) {
+          flat.unshift({ value: MODEL, label: MODEL });
+        }
+        modelPicker.innerHTML = "";
+        flat.forEach(function(m) {
+          var opt = document.createElement("option");
+          opt.value = m.value;
+          opt.textContent = m.label;
+          if (m.value === MODEL) opt.selected = true;
+          modelPicker.appendChild(opt);
+        });
+        if (flat.length > 1) modelPicker.style.display = "";
+      }).catch(function(e) {
+        console.warn("[widget] model list fetch failed:", e);
+      }));
+    }
+    if (ENABLE_TOOL_PICKER && toolsListEl) {
+      tasks.push(fetch(TOOL_HUB_BASE + "/api/mcp_servers", { headers: { "Accept": "application/json" } }).then(function(r) {
+        return r.ok ? r.json() : { mcp_servers: [] };
+      }).then(function(payload) {
+        hubMcpServers = (payload.mcp_servers || []).filter(function(s) {
+          return anyAllowedByAllowlist(s.name, HUB_TOOLS_ALLOWLIST);
+        });
+        toolsListEl.innerHTML = "";
+        if (hubMcpServers.length === 0) {
+          var empty = document.createElement("div");
+          empty.className = "lmw-tools-empty";
+          empty.textContent = "No hub-registered tools available.";
+          toolsListEl.appendChild(empty);
+          return;
+        }
+        hubMcpServers.forEach(function(s) {
+          var serverBlock = document.createElement("div");
+          serverBlock.className = "lmw-tools-server";
+          var headerRow = document.createElement("div");
+          headerRow.className = "lmw-tools-server-row";
+          var bulkCb = document.createElement("input");
+          bulkCb.type = "checkbox";
+          bulkCb.className = "lmw-tools-server-bulk";
+          bulkCb.title = "Enable all tools on this server";
+          bulkCb.addEventListener("click", function(e) {
+            e.stopPropagation();
+          });
+          bulkCb.addEventListener("change", function() {
+            var shouldOn = bulkCb.checked;
+            (s.tools || []).forEach(function(t) {
+              if (shouldOn) selectedToolIds.add(t.id);
+              else selectedToolIds.delete(t.id);
+            });
+            bulkCb.indeterminate = false;
+            childList.querySelectorAll('input[type="checkbox"]').forEach(function(cb) {
+              cb.checked = shouldOn;
+            });
+            refreshRemoteToolsFromPicker();
+          });
+          var nameSpan = document.createElement("span");
+          nameSpan.className = "lmw-tools-server-name";
+          var toolCount = (s.tools || []).length;
+          nameSpan.textContent = s.name + " (" + toolCount + " tool" + (toolCount === 1 ? "" : "s") + ")";
+          var caret2 = document.createElement("span");
+          caret2.className = "lmw-tools-server-caret";
+          caret2.textContent = "\u25B8";
+          headerRow.appendChild(bulkCb);
+          headerRow.appendChild(nameSpan);
+          headerRow.appendChild(caret2);
+          var childList = document.createElement("div");
+          childList.className = "lmw-tools-server-children";
+          childList.style.display = "none";
+          (s.tools || []).forEach(function(t) {
+            var toolLabel = document.createElement("label");
+            toolLabel.className = "lmw-tools-item lmw-tools-item-child";
+            toolLabel.title = t.description || t.name;
+            var cb = document.createElement("input");
+            cb.type = "checkbox";
+            cb.value = t.id;
+            cb.checked = selectedToolIds.has(t.id);
+            cb.addEventListener("change", function() {
+              if (cb.checked) selectedToolIds.add(t.id);
+              else selectedToolIds.delete(t.id);
+              refreshServerBulkCheckbox(s, bulkCb);
+              refreshRemoteToolsFromPicker();
+            });
+            var span = document.createElement("span");
+            span.textContent = t.name;
+            toolLabel.appendChild(cb);
+            toolLabel.appendChild(span);
+            childList.appendChild(toolLabel);
+          });
+          headerRow.addEventListener("click", function() {
+            var isOpen = childList.style.display !== "none";
+            childList.style.display = isOpen ? "none" : "block";
+            caret2.textContent = isOpen ? "\u25B8" : "\u25BE";
+          });
+          serverBlock.appendChild(headerRow);
+          serverBlock.appendChild(childList);
+          toolsListEl.appendChild(serverBlock);
+          refreshServerBulkCheckbox(s, bulkCb);
+        });
+        refreshRemoteToolsFromPicker();
+      }).catch(function(e) {
+        console.warn("[widget] MCP server list fetch failed:", e);
+      }));
+    }
+    await Promise.all(tasks);
+  }
+  if (modelPicker) {
+    modelPicker.addEventListener("change", function() {
+      MODEL = modelPicker.value;
+    });
+  }
+  if (toolsPicker) {
+    document.addEventListener("click", function(e) {
+      if (!toolsPicker.open) return;
+      if (toolsPicker.contains(e.target)) return;
+      toolsPicker.open = false;
+    });
+  }
+  var pickerLoaded = false;
+  async function ensurePickerLoaded() {
+    if (pickerLoaded) return;
+    pickerLoaded = true;
+    try {
+      await loadHubResourcesForPickers();
+    } catch (e) {
+      pickerLoaded = false;
+      throw e;
+    }
+  }
+  var hostWideTools = [];
+  var hostWidePrompts = [];
+  var resourceContext = null;
+  var resourcePlan = null;
+  var RESOURCE_BUDGET_BYTES = 8e3;
+  restoreConversation();
+  var wellKnownReady = (async function() {
+    var urls = WELL_KNOWN_URLS === null ? [window.location.origin + "/.well-known/mcp.json"] : WELL_KNOWN_URLS;
+    for (var i = 0; i < urls.length; i++) {
+      var tools = await fetchMcpManifest(urls[i]);
+      hostWideTools = hostWideTools.concat(tools);
+    }
+    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 });
+      hostWidePrompts = hostWidePrompts.concat(prompts);
+      if (resourcePlan === null) {
+        var loaded = await loadHostResource({
+          endpoint,
+          budgetBytes: RESOURCE_BUDGET_BYTES,
+          list: listMcpResources,
+          read: readMcpResource,
+          onSkip: function(plan) {
+            console.info("[llm_meta_widget] not attaching " + plan.uri + " (" + plan.reason + ", sizeBytes=" + plan.sizeBytes + ")");
+          }
+        });
+        if (loaded && loaded.plan && loaded.plan.fetch) {
+          resourceContext = loaded.context;
+          resourcePlan = loaded.plan;
+        }
+      }
+    }
+    renderPromptButtons();
+    renderWelcome();
+  })();
+  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 = "";
+  }
+  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 ? "\u274C " : "\u{1F527} ") + tool.name;
+        row.appendChild(chip);
+      });
+      if (body.parentNode) body.parentNode.appendChild(row);
+    });
+    historyEl.scrollTop = historyEl.scrollHeight;
+    return true;
+  }
+  function renderWelcome() {
+    if (!historyEl || historyEl.querySelector(".message")) return;
+    historyEl.textContent = "";
+    var box = document.createElement("div");
+    box.className = "lmw-welcome";
+    var hello = document.createElement("p");
+    hello.className = "lmw-welcome-hello";
+    hello.textContent = GREETING || "Hi \u2014 I can work this page for you. Tell me what you need in your own words" + (hostWidePrompts.length ? ", or start with one of these:" : ".");
+    box.appendChild(hello);
+    var state = window[STATE_GLOBAL] || {};
+    hostWidePrompts.forEach(function(prompt) {
+      var props = promptButtonProps(prompt);
+      var card = document.createElement("div");
+      card.className = "lmw-welcome-card";
+      var start = document.createElement("button");
+      start.type = "button";
+      start.className = "lmw-welcome-start";
+      start.textContent = props.label;
+      start.addEventListener("click", function() {
+        runPromptTemplate(prompt, start);
+      });
+      card.appendChild(start);
+      if (prompt.description) {
+        var why = document.createElement("p");
+        why.className = "lmw-welcome-why";
+        why.textContent = prompt.description;
+        card.appendChild(why);
+      }
+      var summary = promptArgumentSummary(prompt, state);
+      if (summary.length) {
+        var slots = document.createElement("ul");
+        slots.className = "lmw-welcome-slots";
+        summary.forEach(function(slot) {
+          var li = document.createElement("li");
+          li.className = slot.filled ? "filled" : "empty";
+          li.textContent = slot.filled ? slot.name + ": " + (slot.value.length > 60 ? slot.value.slice(0, 60) + "\u2026" : slot.value) : slot.name + ": not set yet \u2014 I'll ask, or work it out";
+          slots.appendChild(li);
+        });
+        card.appendChild(slots);
+      }
+      box.appendChild(card);
+    });
+    historyEl.appendChild(box);
+  }
+  async function runPromptTemplate(prompt, button) {
+    var resolved = resolvePromptArguments(prompt, window[STATE_GLOBAL] || {});
+    var args = resolved.args;
+    var missing = resolved.missing;
+    if (missing.length) {
+      appendTurn("error", 'Cannot run "' + (prompt.title || prompt.name) + '" yet \u2014 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 });
+      var text = promptMessagesToText(result);
+      if (!text) {
+        appendTurn("error", "The server returned an empty prompt.");
+        return;
+      }
+      inputEl.value = text;
+      pendingTurnLabel = promptButtonProps(prompt).label;
+      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;
+    }
+  }
+  var pendingTurnLabel = null;
+  function appendTurn(role, text, turnLabel) {
+    var welcome = historyEl.querySelector(".lmw-welcome");
+    if (welcome) welcome.remove();
+    var div = document.createElement("div");
+    div.className = "message " + role;
+    var label = document.createElement("div");
+    label.className = "message-role";
+    label.textContent = roleLabel(role);
+    var body = document.createElement("div");
+    body.className = "message-content";
+    if (turnLabel) {
+      var details = document.createElement("details");
+      var summary = document.createElement("summary");
+      summary.textContent = turnLabel;
+      var full = document.createElement("div");
+      full.className = "lmw-sent-text";
+      full.textContent = text;
+      details.appendChild(summary);
+      details.appendChild(full);
+      body.appendChild(details);
+    } else {
+      body.textContent = text;
+    }
+    div.appendChild(label);
+    div.appendChild(document.createTextNode(" "));
+    div.appendChild(body);
+    historyEl.appendChild(div);
+    historyEl.scrollTop = historyEl.scrollHeight;
+    body.roleLabel = label;
+    return body;
+  }
+  function renderMarkdownInto(el, mdText) {
+    try {
+      el.innerHTML = marked.parse(mdText);
+    } catch (e) {
+      el.textContent = mdText;
+    }
+  }
+  function roleLabel(role) {
+    if (role === "user") return "\u{1F464} You";
+    if (role === "assistant") return "\u{1F916} " + MODEL;
+    if (role === "system") return "\u2022 system";
+    if (role === "error") return "\u26A0 error";
+    return role;
+  }
+  function markWorking(label) {
+    if (!label || label.classList.contains("is-working")) return;
+    label.innerHTML = '<span class="role-spinner" aria-hidden="true">\u2699\uFE0F</span> Working\u2026';
+    label.classList.add("is-working");
+  }
+  function markDone(label) {
+    if (!label || !label.classList.contains("is-working")) return;
+    label.classList.remove("is-working");
+    label.textContent = roleLabel("assistant");
+  }
+  var liveChips = null;
+  var pendingChips = [];
+  function chipRow() {
+    if (liveChips && liveChips.parentNode) return liveChips;
+    if (!activeAssistantBody || !activeAssistantBody.parentNode) return null;
+    liveChips = document.createElement("div");
+    liveChips.className = "lmw-tool-chips";
+    activeAssistantBody.parentNode.appendChild(liveChips);
+    return liveChips;
+  }
+  function announceToolCall(toolCall) {
+    var row = chipRow();
+    if (!row) return;
+    var chip = document.createElement("span");
+    chip.className = "lmw-tool-chip running";
+    chip.textContent = "\u23F3 " + toolCall.name;
+    chip.dataset.tool = toolCall.name;
+    row.appendChild(chip);
+    pendingChips.push(chip);
+    historyEl.scrollTop = historyEl.scrollHeight;
+  }
+  function resolveToolCall(outcome) {
+    var idx = pendingChips.findIndex(function(c) {
+      return c.dataset.tool === outcome.toolCall.name;
+    });
+    var chip = idx === -1 ? null : pendingChips.splice(idx, 1)[0];
+    if (!chip) return;
+    chip.className = "lmw-tool-chip" + (outcome.error ? " error" : "");
+    chip.textContent = (outcome.error ? "\u274C " : "\u{1F527} ") + outcome.toolCall.name;
+    if (outcome.error) chip.title = outcome.error.message || String(outcome.error);
+  }
+  var currentThinkingBlock = null;
+  var currentThinkingBody = null;
+  var activeAssistantBody = null;
+  function ensureThinkingBlock() {
+    if (currentThinkingBody) return currentThinkingBody;
+    var details = document.createElement("details");
+    details.className = "message-thinking";
+    details.open = true;
+    details.classList.add("thinking-active");
+    var summary = document.createElement("summary");
+    summary.textContent = "\u{1F914} thinking\u2026";
+    var dots = document.createElement("span");
+    dots.className = "thinking-dots";
+    for (var i = 0; i < 3; i++) {
+      var dot = document.createElement("span");
+      dot.textContent = ".";
+      dots.appendChild(dot);
+    }
+    summary.appendChild(dots);
+    var body = document.createElement("div");
+    body.className = "message-thinking-content";
+    details.appendChild(summary);
+    details.appendChild(body);
+    if (activeAssistantBody && activeAssistantBody.parentNode) {
+      activeAssistantBody.parentNode.insertBefore(details, activeAssistantBody);
+    } else {
+      historyEl.appendChild(details);
+    }
+    historyEl.scrollTop = historyEl.scrollHeight;
+    currentThinkingBlock = details;
+    currentThinkingBody = body;
+    return body;
+  }
+  function collapseThinkingBlock() {
+    if (currentThinkingBlock) {
+      currentThinkingBlock.classList.remove("thinking-active");
+      currentThinkingBlock.open = false;
+      var summary = currentThinkingBlock.querySelector("summary");
+      if (summary) summary.textContent = "\u{1F914} thinking (finished)";
+    }
+    currentThinkingBlock = null;
+    currentThinkingBody = null;
+  }
+  function currentPageState() {
+    var reader = window[STATE_GLOBAL] || {};
+    var out = {};
+    Object.keys(reader).forEach(function(k) {
+      try {
+        out[k] = reader[k]();
+      } catch (e) {
+        out[k] = "<error: " + e.message + ">";
+      }
+    });
+    return out;
+  }
+  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.",
+      "",
+      "RULES for tool use:",
+      "1. If the user's question can be answered from the Current page state below, answer directly with a plain-text response \u2014 do NOT invoke a tool.",
+      '2. If the user requests a state change, or needs information not in the page state, invoke the matching tool via a function call. Do not describe your intent in text without actually invoking (a textual promise like "I will add X" is a failure).',
+      "3. After a tool returns a result, use it: either take the next step the task needs, or \u2014 if the task is done \u2014 answer in plain text. Do not stop silently after a tool call.",
+      "4. NEVER repeat a call you have already made with the same or similar arguments \u2014 its result is already in the conversation history.",
+      "",
+      "Current page state:",
+      JSON.stringify(currentPageState(), null, 2)
+    ].concat(resourceLines || []).join("\n");
+  }
+  async function resourceLinesForThisTurn() {
+    var turn = await resourceLinesForTurn({
+      plan: resourcePlan,
+      cached: resourceContext,
+      endpoint: resourcePlan && resourcePlan.endpoint,
+      read: readMcpResource,
+      budgetBytes: RESOURCE_BUDGET_BYTES
+    });
+    resourceContext = turn.cached;
+    return turn.lines;
+  }
+  var currentAbort = null;
+  clearBtn.addEventListener("click", function() {
+    if (currentAbort) {
+      try {
+        currentAbort.abort();
+      } catch (e) {
+      }
+    }
+    conversation = [];
+    conversationStore.clear();
+    historyEl.innerHTML = "";
+    renderWelcome();
+  });
+  inputEl.addEventListener("keydown", function(e) {
+    if (e.key === "Enter" && !e.shiftKey && !e.isComposing) {
+      e.preventDefault();
+      if (typeof formEl.requestSubmit === "function") formEl.requestSubmit();
+      else formEl.dispatchEvent(new Event("submit", { cancelable: true }));
+    }
+  });
+  formEl.addEventListener("submit", async function(event) {
+    event.preventDefault();
+    var userText = inputEl.value.trim();
+    if (!userText) return;
+    inputEl.value = "";
+    appendTurn("user", userText, pendingTurnLabel);
+    pendingTurnLabel = null;
+    if (currentAbort) {
+      try {
+        currentAbort.abort();
+      } catch (e) {
+      }
+    }
+    currentAbort = new AbortController();
+    var assistantBody = appendTurn("assistant", "");
+    activeAssistantBody = assistantBody;
+    liveChips = null;
+    pendingChips = [];
+    markWorking(assistantBody.roleLabel);
+    var assistantMarkdown = "";
+    try {
+      await wellKnownReady;
+      var resourceLines = await resourceLinesForThisTurn();
+      var messages = [{ role: "system", content: currentSystemPrompt(resourceLines) }].concat(conversation.map(function(t) {
+        return { role: t.role, content: t.content };
+      })).concat([{ role: "user", content: userText }]);
+      var result = await runChatLoop({
+        baseUrl: LLM_BASE,
+        toolHubUrl: TOOL_HUB_BASE,
+        apiKeyUuid: API_KEY_UUID,
+        modelName: MODEL,
+        messages,
+        localTools,
+        remoteTools,
+        hostWideTools,
+        aiActions: window[ACTIONS_GLOBAL] || {},
+        maxRounds: MAX_ROUNDS,
+        provider: LLM_PROVIDER === "ollama" ? "ollama" : "hub",
+        signal: currentAbort.signal,
+        onToolCall: function(toolCall) {
+          announceToolCall(toolCall);
+        },
+        onToolDispatched: function(outcome) {
+          resolveToolCall(outcome);
+        },
+        onPhase: function(name) {
+          if (name === "responding") markDone(assistantBody.roleLabel);
+          else markWorking(assistantBody.roleLabel);
+        },
+        onRoundStart: function(roundIdx) {
+          markWorking(assistantBody.roleLabel);
+          collapseThinkingBlock();
+        },
+        onThinkingDelta: function(delta) {
+          var body = ensureThinkingBlock();
+          body.appendChild(document.createTextNode(delta));
+          body.scrollTop = body.scrollHeight;
+          historyEl.scrollTop = historyEl.scrollHeight;
+        },
+        onTextDelta: function(delta) {
+          markDone(assistantBody.roleLabel);
+          collapseThinkingBlock();
+          assistantMarkdown += delta;
+          renderMarkdownInto(assistantBody, assistantMarkdown);
+          historyEl.scrollTop = historyEl.scrollHeight;
+        }
+      });
+      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();
+      result.dispatched.forEach(function(d) {
+        resolveToolCall(d);
+      });
+      pendingChips.forEach(function(chip) {
+        chip.className = "lmw-tool-chip";
+        chip.textContent = "\u{1F527} " + chip.dataset.tool;
+      });
+      pendingChips = [];
+      if (result.skipped.length > 0) {
+        appendTurn("system", "Not available on this page: " + result.skipped.map(function(t) {
+          return t.name;
+        }).join(", "));
+      }
+      if (result.stopped_reason && result.stopped_reason !== "duplicate_tool_calls") {
+        appendTurn(
+          "system",
+          "The assistant reached its tool-use limit before finishing. The reply above may be incomplete \u2014 try asking again or rephrasing."
+        );
+      }
+    } catch (err) {
+      if (err.name === "AbortError" || /aborted/i.test(err.message || "")) {
+        appendTurn("system", "\u23F9 stopped");
+      } else {
+        appendTurn("error", err.message);
+      }
+    } finally {
+      markDone(assistantBody.roleLabel);
+      collapseThinkingBlock();
+      activeAssistantBody = null;
+      currentAbort = null;
+    }
+  });
+}
+export {
+  LlmMetaWidgetElement
+};