eddie-jekyll 0.4.0 → 0.4.2

data/assets/eddie-sw-agent.js

@@ -0,0 +1,846 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Generated by widget/build.sh from widget/src/eddie-sw.js and widget/src/lib/*.js; edit those instead.
+"use strict";
+const EDDIE_ASSET_VERSION = "c0fdc503e01a";
+import * as webllm from "https://cdn.jsdelivr.net/npm/@mlc-ai/web-llm@0.2.84/+esm";
+const EDDIE_SW_TIER = "agent";
+const initLiteWasm = null, liteWasmApi = null, EDDIE_LITE_WASM = null,
+      initDenseWasm = null, denseWasmApi = null, EDDIE_DENSE_WASM = null, transformers = null;
+const EddieLib = {};
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Agent helpers the widget shows in its UI: model selection, evidence
+// assembly, stream display and the FAQ gate. Pure functions; no WebLLM, no
+// DOM. The prompts and answer post-processing that run beside the model
+// live in agent-llm.js (bundled only into the agent engine's hosts).
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  const NOHIT = "The site doesn't cover that.";
+
+  const AGENT_MODEL_SIZES = {
+    "Qwen3.5-0.8B": 0.4e9,
+    "Qwen3.5-2B": 1.2e9,
+    "Qwen3.5-4B": 2.3e9,
+  };
+  const TWO_GIB = 2 * 1024 * 1024 * 1024;
+
+  /** Strip the WebLLM variant suffix to get the family name shown to visitors. */
+  function baseModelId(id) {
+    return String(id).replace(/-q\d+f(16|32)_\d+-MLC$/i, "");
+  }
+
+  function agentModelBytes(id) {
+    const base = baseModelId(id);
+    return Object.prototype.hasOwnProperty.call(AGENT_MODEL_SIZES, base) ? AGENT_MODEL_SIZES[base] : null;
+  }
+
+  /**
+   * Choose the WebLLM model id.
+   * opts: { mode: "auto"|"light"|"quality"|<id>, maxBufferSize, isMobile, hasF16 }
+   *
+   * "light" and "quality" are the two sizes the settings panel offers by
+   * name; "auto" picks between them from the adapter's buffer limit.
+   */
+  function selectAgentModel(opts) {
+    const o = opts || {};
+    const mode = (o.mode || "auto").trim();
+    const suffix = o.hasF16 ? "-q4f16_1-MLC" : "-q4f32_1-MLC";
+    let base;
+    if (mode === "auto") {
+      const big = Number(o.maxBufferSize) >= TWO_GIB && !o.isMobile;
+      base = big ? "Qwen3.5-2B" : "Qwen3.5-0.8B";
+    } else if (mode === "quality") {
+      base = "Qwen3.5-2B";
+    } else if (mode === "light") {
+      base = "Qwen3.5-0.8B";
+    } else {
+      return { id: mode, base: baseModelId(mode), sizeBytes: agentModelBytes(mode), explicit: true };
+    }
+    const id = base + suffix;
+    return { id, base, sizeBytes: AGENT_MODEL_SIZES[base], explicit: false };
+  }
+
+  function isMobileDevice(nav) {
+    const n = nav || {};
+    if (n.userAgentData && typeof n.userAgentData.mobile === "boolean") {
+      return n.userAgentData.mobile;
+    }
+    return /Mobi|Android|iPhone|iPad|iPod|Windows Phone/i.test(n.userAgent || "");
+  }
+
+  /**
+   * Display text for a partial stream: complete think blocks removed, and
+   * anything after an unclosed <think> hidden until it closes.
+   */
+  function visibleStreamText(partial) {
+    if (!partial) return "";
+    let out = String(partial).replace(/<think>[\s\S]*?<\/think>/g, "");
+    const open = out.indexOf("<think>");
+    if (open >= 0) out = out.substring(0, open);
+    return out.replace(/^\s+/, "");
+  }
+
+  function urlKey(url) {
+    return String(url || "").replace(/#.*$/, "").replace(/\/+$/, "").toLowerCase();
+  }
+
+  /**
+   * Round-robin merge of several result lists, deduplicated by URL, at most
+   * `max` items. Each result keeps its own fields.
+   */
+  function mergeEvidence(lists, max) {
+    const limit = max == null ? 6 : max;
+    const seen = new Set();
+    const out = [];
+    const arrays = (lists || []).map((l) => (Array.isArray(l) ? l : []));
+    const longest = arrays.reduce((n, l) => Math.max(n, l.length), 0);
+    for (let i = 0; i < longest && out.length < limit; i++) {
+      for (const list of arrays) {
+        if (out.length >= limit) break;
+        const r = list[i];
+        if (!r || !r.url) continue;
+        const key = urlKey(r.url);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(r);
+      }
+    }
+    return out;
+  }
+
+  // FAQ card gate: prefer the WASM's fused `confident` flag (qa_lookup v0.4.1+);
+  // older indexes only carry a dense score, so fall back to a plain cutoff.
+  function faqPasses(hit, qaMode) {
+    if (!hit || typeof hit !== "object") return false;
+    if (qaMode === "off") return false;
+    if (qaMode === "always") return true;
+    if (typeof hit.confident === "boolean") return hit.confident;
+    return typeof hit.score === "number" && hit.score >= 0.5;
+  }
+
+  // Turn confident QA hits into agent evidence items ("Q: … A: …") so the
+  // answer model sees the FAQ lane, not only chunk text.
+  function qaEvidence(hits, max) {
+    const limit = max == null ? 2 : max;
+    const out = [];
+    for (const h of Array.isArray(hits) ? hits : []) {
+      if (out.length >= limit) break;
+      if (!faqPasses(h, "auto")) continue;
+      const q = String(h.question || "").trim();
+      const a = String(h.answer || "").trim();
+      if (!q || !a) continue;
+      out.push({ title: "FAQ: " + q, url: h.source_url || "", text: "Q: " + q + "\nA: " + a, faq: true });
+    }
+    return out;
+  }
+
+  return {
+    faqPasses,
+    qaEvidence,
+    NOHIT,
+    AGENT_MODEL_SIZES,
+    baseModelId,
+    agentModelBytes,
+    selectAgentModel,
+    isMobileDevice,
+    visibleStreamText,
+    mergeEvidence,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Agent LLM helpers used only where the model runs (agent-engine.js hosts:
+// the agent service worker and the page-side agent worker): prompts, plan
+// parsing and answer post-processing. Split out of agent.js so the widget
+// bundle carries only the model-selection and evidence helpers it shows in
+// the UI. Bundles that include this file always include agent.js first.
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  // The fallback sentence lives in agent.js (the widget shows it too); the
+  // bundles concatenate agent.js ahead of this file, node requires it.
+  const NOHIT = (typeof module === "object" && module && module.exports ? require("./agent.js") : EddieLib).NOHIT;
+  const NOHIT_RE = /\bthe site (?:doesn['’]t|does not|didn['’]t|did not) cover (?:that|this|it)\.?/gi;
+
+  const PLAN_SCHEMA = {
+    type: "object",
+    properties: {
+      queries: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 3 },
+    },
+    required: ["queries"],
+  };
+
+  function planPrompt(site) {
+    return `You write search queries for a site search engine. The site is ${site}. Reply with JSON only: {"queries": ["..."]}. Give 1 to 3 different short keyword queries (2 to 5 words each, no punctuation) that a site search engine would match against page text. Each query must be different. Do not answer the question.`;
+  }
+
+  function answerPrompt(site) {
+    return `You answer visitor questions about ${site} using only the numbered sources below the question. Answer the question directly in the first sentence. Write 1 to 3 sentences in your own words; never repeat a source's wording. End each sentence with the numbers of the sources it comes from, like [2] or [1][3]. Never cite a number that is not in the list. Do not add calculations or inferences that are not in the sources. If no source answers the question, your entire reply is: ${NOHIT} Never mix that sentence with an answer. Never use outside knowledge.`;
+  }
+
+  /** Remove <think>…</think> blocks; a dangling <think> loses only the tag. */
+  function stripThink(text) {
+    if (!text) return "";
+    let out = String(text).replace(/<think>[\s\S]*?<\/think>/g, "");
+    out = out.replace(/<think>/g, "").replace(/<\/think>/g, "");
+    return out.trim();
+  }
+
+  function extractJsonObject(text) {
+    const s = String(text);
+    const start = s.indexOf("{");
+    const end = s.lastIndexOf("}");
+    if (start < 0 || end <= start) return null;
+    try {
+      return JSON.parse(s.substring(start, end + 1));
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function cleanQuery(q) {
+    return String(q)
+      .replace(/\/?no_think/gi, "")
+      .replace(/[\s"'`*]+$/g, "")
+      .replace(/^[\s"'`*\-\d.)]+/g, "")
+      .replace(/\s+/g, " ")
+      .trim();
+  }
+
+  /** Parse the planner reply into 1..3 distinct queries; falls back to the question. */
+  function parsePlan(text, question) {
+    const cleaned = stripThink(text);
+    const obj = extractJsonObject(cleaned);
+    const raw = obj && Array.isArray(obj.queries) ? obj.queries : [];
+    const seen = new Set();
+    const out = [];
+    for (const item of raw) {
+      if (typeof item !== "string") continue;
+      const q = cleanQuery(item);
+      if (q.length < 2 || q.length > 80) continue;
+      const key = q.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(q);
+      if (out.length === 3) break;
+    }
+    if (out.length === 0 && question && question.trim()) {
+      out.push(question.trim());
+    }
+    return out;
+  }
+
+  /** Cut to `max` characters at a word boundary, with an ellipsis. */
+  function truncateText(text, max) {
+    const limit = max == null ? 700 : max;
+    const s = String(text || "").replace(/\s+/g, " ").trim();
+    if (s.length <= limit) return s;
+    const cut = s.lastIndexOf(" ", limit - 1);
+    return s.substring(0, cut > limit * 0.6 ? cut : limit - 1).trim() + "…";
+  }
+
+  /** `[n] title (url)\ntext` blocks joined by blank lines. */
+  function formatEvidence(items, maxChars) {
+    return (items || [])
+      .map((e, i) => `[${i + 1}] ${e.title || e.url} (${e.url})\n${truncateText(e.text || e.snippet || "", maxChars)}`)
+      .join("\n\n");
+  }
+
+  function sourcesPrompt(items, question, maxChars) {
+    return `Sources:\n\n${formatEvidence(items, maxChars)}\n\nQuestion: ${question}`;
+  }
+
+  /**
+   * Post-process a raw model answer against the evidence list.
+   * Returns { answer, citations: [{n, url, title}], nohit }.
+   */
+  function postProcessAnswer(raw, evidence) {
+    const ev = Array.isArray(evidence) ? evidence : [];
+    let text = stripThink(raw);
+    // **[1]** -> [1]
+    text = text.replace(/\*\*\s*((?:\[\s*\d+(?:\s*,\s*\d+)*\s*\]\s*)+)\*\*/g, "$1");
+    // Lines that are only citation markers belong to the previous line.
+    const lines = text.split(/\r?\n/);
+    const merged = [];
+    for (const line of lines) {
+      const t = line.trim();
+      if (t && /^(?:\[\s*\d+(?:\s*,\s*\d+)*\s*\]\s*)+$/.test(t)) {
+        let j = merged.length - 1;
+        while (j >= 0 && merged[j].trim() === "") j--;
+        if (j >= 0) {
+          // Append only markers the previous line does not already carry.
+          const prev = merged[j];
+          const fresh = (t.match(/\[\s*\d+(?:\s*,\s*\d+)*\s*\]/g) || []).filter((m) => !prev.includes(m.replace(/\s+/g, "")));
+          merged.length = j + 1;
+          if (fresh.length) merged[j] = prev.replace(/\s+$/, "") + " " + fresh.join("");
+          continue;
+        }
+      }
+      merged.push(line);
+    }
+    text = merged.join("\n");
+
+    // Drop the fallback sentence when anything else remains.
+    const withoutFallback = text.replace(NOHIT_RE, "").replace(/[ \t]+\n/g, "\n").trim();
+    const residue = withoutFallback
+      .replace(/\[\s*\d+(?:\s*,\s*\d+)*\s*\]/g, "")
+      .replace(/^\s*(?:yes|no)\b/i, "")
+      .replace(/[\s.,;:!?'"*-]+/g, "");
+    const onlyFallback = residue === "";
+    if (onlyFallback) {
+      return { answer: NOHIT, citations: [], nohit: true };
+    }
+    text = withoutFallback;
+
+    // Map [n] citations to evidence; drop out-of-range ones.
+    const cited = [];
+    const seen = new Set();
+    text = text.replace(/\[\s*(\d+(?:\s*,\s*\d+)*)\s*\]/g, (_, body) => {
+      const nums = body.split(",").map((x) => Number(x.trim()));
+      let out = "";
+      for (const n of nums) {
+        if (n >= 1 && n <= ev.length) {
+          out += `[${n}]`;
+          if (!seen.has(n)) {
+            seen.add(n);
+            cited.push(n);
+          }
+        }
+      }
+      return out;
+    });
+    // Collapse duplicate adjacent markers ("[1][1]") and tidy whitespace.
+    text = text.replace(/(\[\d+\])(?:\s*\1)+/g, "$1");
+    text = text.replace(/[ \t]{2,}/g, " ").replace(/ +([.,;:!?])/g, "$1").replace(/\n{3,}/g, "\n\n").trim();
+    const citations = cited
+      .sort((a, b) => a - b)
+      .map((n) => ({ n, url: ev[n - 1].url, title: ev[n - 1].title || ev[n - 1].url }));
+    return { answer: text, citations, nohit: text === "" };
+  }
+
+  return {
+    PLAN_SCHEMA,
+    planPrompt,
+    answerPrompt,
+    sourcesPrompt,
+    stripThink,
+    parsePlan,
+    truncateText,
+    formatEvidence,
+    postProcessAnswer,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Eddie agent engine, host-independent.
+//
+// Everything the agent worker does (WebLLM load, plan, ask/stream, abort with
+// the drained-stream lock rule) behind an `env` the host supplies:
+//
+//   createAgentEngine({
+//     post(message)     broadcast sink (unused today; progress goes to the loaders)
+//     loadWebLLM()      -> Promise of the WebLLM module
+//     now()             optional clock (tests)
+//   })
+//
+// `engine.handle(msg, reply)` dispatches one protocol message; `reply` is
+// the sink for that message's answers (progress/loaded for `load`,
+// plan_result, token/done/aborted for `ask`, error). Message shapes are in
+// widget/README.md ("Worker protocol", agent section).
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  const EVIDENCE_CHARS = 700;
+  const NOT_LOADED = "model not loaded";
+
+  function createAgentEngine(env) {
+    const lib = typeof EddieLib === "object" && EddieLib ? EddieLib : env.lib;
+    const now = env.now || (() => (typeof performance === "object" && performance.now ? performance.now() : Date.now()));
+
+    let webllm = null;
+    let engine = null;
+    let modelId = null;
+    let loading = null; // { model, promise, waiters: [reply] }
+    let active = null; // { requestId, aborted, reply }
+    let queue = Promise.resolve();
+
+    function handle(msg, reply) {
+      const m = msg || {};
+      const out = reply || env.post;
+      switch (m.type) {
+        case "load":
+          return load(m, out);
+        case "plan":
+          return enqueue(() => plan(m, out), m.requestId, out);
+        case "ask":
+          return enqueue(() => ask(m, out), m.requestId, out);
+        case "abort":
+          abort(m);
+          return Promise.resolve();
+        default:
+          postError(out, m.requestId, `unknown message type ${String(m.type)}`);
+          return Promise.resolve();
+      }
+    }
+
+    /** Snapshot for the service worker's `state` reply. */
+    function snapshot() {
+      return {
+        model: modelId,
+        loaded: !!engine,
+        loading: loading ? loading.model : null,
+        active: active ? active.requestId : null,
+      };
+    }
+
+    function enqueue(fn, requestId, reply) {
+      queue = queue
+        .then(() => {
+          console.debug("eddie agent engine: start", requestId);
+          return fn();
+        })
+        .catch((err) => postError(reply, requestId, describe(err)))
+        .then(() => console.debug("eddie agent engine: end", requestId));
+      return queue;
+    }
+
+    async function load(msg, reply) {
+      const model = String(msg.model || "");
+      if (!model) {
+        postError(reply, undefined, "load: model is required");
+        return;
+      }
+      if (engine && modelId === model) {
+        reply({ type: "loaded", model, loadMs: 0, cached: true });
+        return;
+      }
+      if (loading) {
+        // Another page (or an earlier message) is loading. Same model: join
+        // it, the fan-out delivers progress and loaded/error to us too.
+        // Different model: wait for it to settle, then load ours.
+        const join = loading.model === model;
+        if (join) loading.waiters.push(reply);
+        try {
+          await loading.promise;
+        } catch (_) {
+          // the fan-out already reported the error to the joined waiters
+        }
+        if (join) return;
+        if (engine && modelId === model) {
+          reply({ type: "loaded", model, loadMs: 0, cached: true });
+          return;
+        }
+      }
+      const job = { model, waiters: [reply], promise: null };
+      const fanout = (message) => {
+        for (const w of job.waiters) w(message);
+      };
+      job.promise = (async () => {
+        const t0 = now();
+        if (!webllm) {
+          fanout({ type: "progress", text: "Loading the WebLLM runtime…", progress: 0 });
+          webllm = await env.loadWebLLM();
+        }
+        if (engine) {
+          try {
+            await engine.unload();
+          } catch (_) {
+            // ignore
+          }
+          engine = null;
+          modelId = null;
+        }
+        const created = await webllm.CreateMLCEngine(model, {
+          initProgressCallback: (p) => {
+            fanout({
+              type: "progress",
+              text: p && p.text ? p.text : "Loading model…",
+              progress: p && typeof p.progress === "number" ? p.progress : null,
+            });
+          },
+        });
+        engine = created;
+        modelId = model;
+        fanout({ type: "loaded", model, loadMs: Math.round(now() - t0) });
+      })();
+      loading = job;
+      try {
+        await job.promise;
+      } catch (err) {
+        engine = null;
+        modelId = null;
+        fanout({ type: "error", requestId: undefined, message: describe(err) });
+      } finally {
+        if (loading === job) loading = null;
+      }
+    }
+
+    function requireEngine() {
+      if (!engine) throw new Error(NOT_LOADED);
+    }
+
+    async function plan(msg, reply) {
+      requireEngine();
+      const question = String(msg.question || "").trim();
+      const site = String(msg.site || "this website");
+      const t0 = now();
+      const replyMsg = await engine.chat.completions.create({
+        messages: [
+          { role: "system", content: lib.planPrompt(site) },
+          { role: "user", content: question },
+        ],
+        temperature: 0,
+        max_tokens: 100,
+        response_format: { type: "json_object", schema: JSON.stringify(lib.PLAN_SCHEMA) },
+        extra_body: { enable_thinking: false },
+      });
+      const content = replyMsg && replyMsg.choices && replyMsg.choices[0] && replyMsg.choices[0].message ? replyMsg.choices[0].message.content : "";
+      const queries = lib.parsePlan(content, question);
+      reply({ type: "plan_result", requestId: msg.requestId, queries, ms: Math.round(now() - t0) });
+    }
+
+    async function ask(msg, reply) {
+      requireEngine();
+      const requestId = msg.requestId;
+      const question = String(msg.question || "").trim();
+      const site = String(msg.site || "this website");
+      const evidence = Array.isArray(msg.evidence) ? msg.evidence.filter((e) => e && e.url) : [];
+      if (evidence.length === 0) {
+        reply({
+          type: "done",
+          requestId,
+          answer: lib.NOHIT,
+          citations: [],
+          nohit: true,
+          raw: "",
+          usage: { ttftMs: 0, totalMs: 0, tps: null, completionTokens: 0 },
+        });
+        return;
+      }
+      active = { requestId, aborted: false, reply };
+      const t0 = now();
+      let first = 0;
+      let text = "";
+      let usage = null;
+      try {
+        const stream = await engine.chat.completions.create({
+          messages: [
+            { role: "system", content: lib.answerPrompt(site) },
+            { role: "user", content: lib.sourcesPrompt(evidence, question, EVIDENCE_CHARS) },
+          ],
+          stream: true,
+          stream_options: { include_usage: true },
+          temperature: 0,
+          frequency_penalty: 0.5,
+          presence_penalty: 0,
+          max_tokens: 220,
+          extra_body: { enable_thinking: false },
+        });
+        // Never break out of this loop: WebLLM releases its generation lock at
+        // the end of the async generator, and an early exit skips that release,
+        // hanging every later completion. After interruptGenerate() the stream
+        // ends by itself within one decode step; drop the tokens until then.
+        for await (const chunk of stream) {
+          if (active.aborted) continue;
+          const delta = chunk && chunk.choices && chunk.choices[0] && chunk.choices[0].delta ? chunk.choices[0].delta.content : null;
+          if (delta) {
+            if (!first) first = now();
+            text += delta;
+            reply({ type: "token", requestId, text: delta });
+          }
+          if (chunk && chunk.usage) usage = chunk.usage;
+        }
+      } finally {
+        const wasAborted = active && active.aborted;
+        active = null;
+        if (wasAborted) {
+          reply({ type: "aborted", requestId });
+          return;
+        }
+      }
+      const processed = lib.postProcessAnswer(text, evidence);
+      const totalMs = Math.round(now() - t0);
+      reply({
+        type: "done",
+        requestId,
+        answer: processed.answer,
+        citations: processed.citations,
+        nohit: processed.nohit,
+        raw: text,
+        usage: {
+          ttftMs: first ? Math.round(first - t0) : totalMs,
+          totalMs,
+          tps: usage && usage.extra && typeof usage.extra.decode_tokens_per_s === "number" ? Math.round(usage.extra.decode_tokens_per_s) : null,
+          completionTokens: usage ? usage.completion_tokens : null,
+        },
+      });
+    }
+
+    function abort(msg) {
+      console.debug("eddie agent engine: abort", msg.requestId, active ? active.requestId : null);
+      if (!active) return;
+      if (msg.requestId != null && msg.requestId !== active.requestId) return;
+      active.aborted = true;
+      try {
+        if (engine) engine.interruptGenerate();
+      } catch (err) {
+        console.warn("eddie agent: interrupt failed", err);
+      }
+    }
+
+    /** Abort the active run if it belongs to a page that went away. */
+    function abortIfOwner(reply) {
+      if (active && active.reply === reply) abort({ requestId: active.requestId });
+    }
+
+    function postError(reply, requestId, message) {
+      reply({ type: "error", requestId: requestId == null ? undefined : requestId, message });
+    }
+
+    return { handle, state: snapshot, abortIfOwner };
+  }
+
+  function describe(err) {
+    if (err == null) return "unknown error";
+    if (typeof err === "string") return err;
+    return err.message || String(err);
+  }
+
+  /** True for the engine's "not loaded" replies (the client re-runs load). */
+  function isModelNotLoadedMessage(message) {
+    return typeof message === "string" && message.indexOf(NOT_LOADED) === 0;
+  }
+
+  return { createAgentEngine, AGENT_NOT_LOADED: NOT_LOADED, isModelNotLoadedMessage };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Eddie service worker: a persistent host for the search engine and the
+// agent, so a navigation within the site does not throw away the loaded
+// index, the dense model or the WebLLM engine.
+//
+// One source, four builds (widget/build.sh), because a service worker may
+// not import() anything: every dependency is a static import that build.sh
+// prepends per tier, along with `EDDIE_SW_TIER`:
+//
+//   eddie-sw-lite.js   initLiteWasm / liteWasmApi (eddie-lite-esm.js)
+//   eddie-sw-dense.js  lite + initDenseWasm / denseWasmApi (eddie-dense-esm.js)
+//   eddie-sw-gpu.js    lite + `transformers` (eddie-transformers-sw.js, the
+//                      copy whose onnxruntime-web imports point at the ORT
+//                      bundle build); search only, never WebLLM
+//   eddie-sw-agent.js  `webllm` (jsDelivr; the esm.run alias redirects, and
+//                      service worker script fetches reject redirects) and
+//                      the agent engine only; never a search host
+//
+// Each tier is registered by the widget as a *module* service worker in
+// its own scope under the asset directory (`/eddie/sw/<tier>/`), so a
+// visitor who never accepts a model never installs the gpu tier's imports
+// and one who never asks the agent a question never installs WebLLM.
+// The worker never handles `fetch`, so the browser does not start it for
+// navigations; pages reach it through
+// `registration.active.postMessage({type: "connect"}, [port])`, one
+// MessageChannel per page and engine ("search" or "agent"), and then speak
+// exactly the dedicated-worker protocols over that port. Three extra
+// messages exist on every port: `hello` (answered with the host's tier and
+// capabilities and both engines' state), `ping` -> `pong` (keepalive: Chrome
+// stops an idle service worker after ~30 s) and `state`.
+//
+// widget/build.sh concatenates widget/src/lib/*.js ahead of this file.
+
+"use strict";
+
+const lib = EddieLib;
+
+const SEARCH_TYPES = new Set(["init", "cache_check", "cache_clear", "search", "page", "chunk", "qa"]);
+const AGENT_TYPES = new Set(["load", "plan", "ask", "abort"]);
+const startedAt = Date.now();
+const hasGpu = !!(self.navigator && navigator.gpu && typeof navigator.gpu.requestAdapter === "function");
+const canRunOnnx = EDDIE_SW_TIER === "gpu" && hasGpu;
+
+/** A rejection that names the tier able to host what this one cannot; the widget moves the search there. */
+function tierError(tier, what) {
+  const e = new Error(`the ${EDDIE_SW_TIER} service worker has no ${what}; the ${tier} tier hosts it`);
+  e.eddieTier = tier;
+  return e;
+}
+
+const connections = new Set(); // { port, kind, reply }
+
+function broadcast(kind, message) {
+  for (const c of connections) {
+    if (c.kind === kind) c.reply(message);
+  }
+}
+
+/** ORT must use the factory embedded in its bundle build: no import() here. */
+function configureTransformers(tf) {
+  const onnx = tf.env && tf.env.backends && tf.env.backends.onnx;
+  if (!onnx || !onnx.wasm) return;
+  tf.env.useWasmCache = false;
+  onnx.wasm.numThreads = 1;
+  const ver = onnx.versions && onnx.versions.web;
+  if (ver && !onnx.wasm.wasmPaths) {
+    onnx.wasm.wasmPaths = { wasm: `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ver}/dist/ort-wasm-simd-threaded.asyncify.wasm` };
+  }
+}
+
+const wasmInits = {}; // variant -> Promise
+function loadWasm(baseUrl, variant) {
+  const v = variant || "lite";
+  if (v === "lite") {
+    if (!wasmInits.lite) wasmInits.lite = initLiteWasm({ module_or_path: lib.assetUrl(baseUrl, EDDIE_LITE_WASM, lib.ASSET_VERSION) }).then(() => liteWasmApi);
+    return wasmInits.lite;
+  }
+  if (v === "dense") {
+    if (!initDenseWasm) return Promise.reject(tierError("dense", "CPU embedder"));
+    if (!wasmInits.dense) wasmInits.dense = initDenseWasm({ module_or_path: lib.assetUrl(baseUrl, EDDIE_DENSE_WASM, lib.ASSET_VERSION) }).then(() => denseWasmApi);
+    return wasmInits.dense;
+  }
+  return Promise.reject(new Error(`unknown wasm variant ${String(variant)}`));
+}
+
+// The agent tier bundles no search engine (widget/src/lib/search-engine.js).
+const searchEngine = typeof lib.createSearchEngine === "function"
+  ? lib.createSearchEngine({
+      post: (message) => broadcast("search", message),
+      loadWasm,
+      loadTransformers: async () => {
+        if (!transformers) throw tierError("gpu", "transformers.js");
+        return transformers;
+      },
+      configureTransformers,
+      // Lane *choice* follows the adapter, whatever the tier: a lite worker asks
+      // consent for the webgpu lane, and the widget moves the search to the gpu
+      // tier on accept (or on a tier_required status if the lane is cached).
+      canRunWebGpuLane: hasGpu,
+    })
+  : null;
+
+// Only the agent tier bundles the agent (widget/src/lib/agent*.js) at all.
+const agentEngine = webllm && typeof lib.createAgentEngine === "function"
+  ? lib.createAgentEngine({
+      post: (message) => broadcast("agent", message),
+      loadWebLLM: async () => webllm,
+    })
+  : null;
+
+function capabilities() {
+  return {
+    ok: true,
+    tier: EDDIE_SW_TIER,
+    // The WebGPU runtime this tier hosts (transformers.js or WebLLM) can run.
+    gpu: hasGpu && !!(transformers || webllm),
+    onnx: canRunOnnx,
+    denseWasm: !!initDenseWasm,
+    startedAt,
+    search: searchEngine ? searchEngine.state() : null,
+    agent: agentEngine ? agentEngine.state() : null,
+  };
+}
+
+function attach(port, kind) {
+  const conn = {
+    port,
+    kind: kind === "agent" ? "agent" : "search",
+    reply: (message) => {
+      try {
+        port.postMessage(message);
+      } catch (err) {
+        console.warn("eddie sw: reply failed", err);
+      }
+    },
+  };
+  connections.add(conn);
+  port.onmessage = (e) => route(conn, e.data || {});
+  // Chrome 132+ fires close when the page that owns the other end goes away.
+  port.addEventListener("close", () => detach(conn));
+  port.start();
+}
+
+function detach(conn) {
+  if (!connections.has(conn)) return;
+  connections.delete(conn);
+  if (agentEngine) agentEngine.abortIfOwner(conn.reply);
+  try {
+    conn.port.close();
+  } catch (_) {
+    // ignore
+  }
+}
+
+function route(conn, msg) {
+  switch (msg.type) {
+    case "hello":
+      conn.reply(Object.assign({ type: "hello", requestId: msg.requestId }, capabilities()));
+      return;
+    case "ping":
+      conn.reply({ type: "pong", requestId: msg.requestId });
+      return;
+    case "state":
+      conn.reply(Object.assign({ type: "state", requestId: msg.requestId }, capabilities()));
+      return;
+    case "disconnect":
+      detach(conn);
+      return;
+    default:
+      break;
+  }
+  if (SEARCH_TYPES.has(msg.type)) {
+    if (searchEngine) searchEngine.handle(msg, conn.reply);
+    else conn.reply({ type: "error", requestId: msg.requestId, message: `the ${EDDIE_SW_TIER} service worker has no search engine; the lite tier hosts it` });
+  } else if (AGENT_TYPES.has(msg.type)) {
+    if (agentEngine) agentEngine.handle(msg, conn.reply);
+    else conn.reply({ type: "error", requestId: msg.requestId, message: `the ${EDDIE_SW_TIER} service worker has no agent; the agent tier hosts it` });
+  } else {
+    conn.reply({ type: "error", requestId: msg.requestId, message: `unknown message type ${String(msg.type)}` });
+  }
+}
+
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (e) => {
+  e.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("message", (e) => {
+  const msg = e.data || {};
+  if (msg.type === "connect" && e.ports && e.ports[0]) {
+    attach(e.ports[0], msg.kind);
+  }
+});