kanha-ai 0.1.4 → 0.1.5

package/README.md

@@ -0,0 +1,171 @@
+# kanha-ai
+
+Drop-in AI chatbot widget for bots custom-trained on your own website content with [Kanha](https://kanha.ai).
+
+The model runs on-device in the visitor's browser over WebGPU. There is no inference API in the loop, so conversations stay on the device and you are not billed per message.
+
+## Install
+
+```bash
+npm install kanha-ai
+```
+
+React is a peer dependency for the React entry point. The CDN widget and Web Component have no framework dependency.
+
+## React component
+
+```tsx
+import { KanhaBot } from "kanha-ai";
+
+export default function App() {
+  return (
+    <KanhaBot
+      modelUrl="https://huggingface.co/your-org/your-bot/resolve/main/"
+      botName="Acme Assistant"
+      welcomeMessage="Ask me anything about Acme."
+      suggestions={["What do you sell?", "How does pricing work?"]}
+      theme={{ primaryColor: "#0d9488", position: "bottom-right" }}
+    />
+  );
+}
+```
+
+## React hook
+
+`useKanhaChat` gives you the same engine with no UI, so you can build your own. `loadProgress` is a
+percentage that restarts on each phase of the first load, so pair it with `loadStage` ("Downloading
+model", "Loading cached model", "Preparing GPU", "Almost ready") to explain the number going down.
+
+```tsx
+import { useKanhaChat } from "kanha-ai";
+
+function Chat() {
+  const { messages, input, setInput, send, stop, clear, isLoading, mode, loadProgress, loadStage, error } =
+    useKanhaChat({ modelUrl: "https://huggingface.co/your-org/your-bot/resolve/main/" });
+
+  return (
+    <form onSubmit={(e) => { e.preventDefault(); send(); }}>
+      {messages.map((m, i) => <p key={i}><b>{m.role}</b>: {m.content}</p>)}
+      <input value={input} onChange={(e) => setInput(e.target.value)} disabled={isLoading} />
+    </form>
+  );
+}
+```
+
+## CDN and vanilla JS
+
+```html
+<div id="chat"></div>
+<script type="module">
+  import { mount } from "https://cdn.jsdelivr.net/npm/kanha-ai/dist/widget.js";
+
+  const bot = mount("#chat", {
+    modelUrl: "https://huggingface.co/your-org/your-bot/resolve/main/",
+    botName: "Acme Assistant",
+  });
+</script>
+```
+
+`mount()` returns `{ stop, clear, destroy }` so you can tear the widget down again.
+
+The widget build has no bundler requirement. It pulls the WebGPU runtime at load time from
+`https://cdn.jsdelivr.net/npm/@mlc-ai/web-llm@<version>/+esm`, pinned at publish time to the version
+the package was built against, so a plain `<script type="module">` tag is all you need.
+
+## Web Component
+
+Loading `widget.js` registers `<kanha-bot>` automatically.
+
+```html
+<script type="module" src="https://cdn.jsdelivr.net/npm/kanha-ai/dist/widget.js"></script>
+
+<kanha-bot
+  model-url="https://huggingface.co/your-org/your-bot/resolve/main/"
+  bot-name="Acme Assistant"
+  primary-color="#0d9488"
+  position="bottom-right"
+></kanha-bot>
+```
+
+Props map to kebab-case attributes (`modelUrl` becomes `model-url`, `ragCorpusUrl` becomes `rag-corpus-url`, `repetitionPenalty` becomes `repetition-penalty`). `suggestions` takes a JSON array string. `theme.primaryColor` and `theme.position` are flattened to `primary-color` and `position`.
+
+## Grounded answers with sources
+
+Point `ragCorpusUrl` at the grounding corpus published with your bot and the widget retrieves the
+matching passages before every answer, restricts the model to that context, and renders the source
+pages under the reply.
+
+```html
+<kanha-bot
+  model-url="https://huggingface.co/your-org/your-bot/resolve/main/"
+  rag-corpus-url="https://huggingface.co/your-org/your-bot/resolve/main/rag-corpus.json"
+  bot-name="Acme Assistant"
+></kanha-bot>
+```
+
+When nothing in the corpus matches the question the bot says so instead of guessing, and no model
+call is made. Assistant messages carry the pages they were drawn from as `sources`, so a custom UI
+built on `useKanhaChat` can render its own citations:
+
+```tsx
+{messages.map((m, i) => (
+  <div key={i}>
+    {m.content}
+    {m.sources?.map((s) => <a key={s.url} href={s.url}>{s.title}</a>)}
+  </div>
+))}
+```
+
+`onRetrieveContext` takes precedence when both are set.
+
+## Props
+
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `modelUrl` | `string` | - | Base URL for your bot's model artifacts |
+| `modelLib` | `string` | auto | URL of the matching WebGPU library file, resolved from `modelSize` when omitted |
+| `modelSize` | `string` | `"small"` | Model identity used for runtime selection and metrics |
+| `systemPrompt` | `string` | - | System prompt for the bot |
+| `temperature` | `number` | `0.7` | Sampling temperature (0-2) |
+| `topP` | `number` | `0.8` | Top-p sampling threshold |
+| `repetitionPenalty` | `number` | `1.1` | Penalty on already generated tokens, which suppresses repeated phrasing |
+| `maxTokens` | `number` | `1024` | Max tokens generated per response |
+| `enableThinking` | `boolean` | `false` | Hidden reasoning where the bot supports it |
+| `maxHistoryMessages` | `number` | `12` | Non-system messages sent to the model |
+| `streamUpdateIntervalMs` | `number` | `50` | Minimum delay between visible streaming updates |
+| `cacheBackend` | `"cache" \| "indexeddb"` | `"indexeddb"` | Browser cache backend for downloaded weights |
+| `workerUrl` | `string \| URL` | - | Run inference in a dedicated Web Worker |
+| `contextWindowSize` | `number` | - | Context window override |
+| `onMetrics` | `(m: KanhaChatMetrics) => void` | - | Token usage and latency callback |
+| `onRetrieveContext` | `(query: string) => Promise<string \| null>` | - | Retrieval hook called before generating |
+| `ragPromptTemplate` | `string` | - | Template for retrieved context, with `{context}` and `{query}` |
+| `ragCorpusUrl` | `string` | - | Grounding corpus to retrieve from, which also turns on source links |
+| `botName` | `string` | `"AI Assistant"` | Display name (widget only) |
+| `welcomeMessage` | `string` | `"Ask me anything!"` | Empty-state message (widget only) |
+| `suggestions` | `string[]` | `[]` | Suggested prompts (widget only) |
+| `theme` | `{ primaryColor?, position? }` | teal, bottom-right | Widget theming |
+
+`minRamGb` and `weightBytes` are deprecated and ignored.
+
+## Optional entry points
+
+| Import | What it gives you |
+|--------|-------------------|
+| `kanha-ai` | `KanhaBot`, `useKanhaChat`, types |
+| `kanha-ai/widget` | `mount()` and the `<kanha-bot>` element, no React |
+| `kanha-ai/rag` | `LocalRAG` for in-browser retrieval over your own documents |
+| `kanha-ai/worker` | Prebuilt Web Worker script to pass as `workerUrl` |
+
+`LocalRAG` needs the optional `@huggingface/transformers` peer dependency installed. Pair it with `onRetrieveContext` to ground answers in documents you supply at runtime.
+
+## Browser requirements
+
+WebGPU is required. That means a recent Chrome, Edge, or Chromium-based browser, Safari 18+, or Firefox with WebGPU enabled. Model weights download once and are cached in the browser, so the first message is slower than the rest.
+
+## Docs
+
+Full setup guide, including how to get your bot's model URLs: [kanha.ai/docs/sdk](https://kanha.ai/docs/sdk)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -12,6 +12,7 @@ var ReactMarkdown__default = /*#__PURE__*/_interopDefault(ReactMarkdown);
 
 // src/webllm.ts
 var MODEL_ID = "kanha-custom-model";
+var MINICPM5_SYSTEM_PROMPT = "Answer only from the supplied context. Be concise. If the answer is absent from the context, respond exactly: I can't answer that from the provided context.";
 var PREBUILT_MODEL_BY_SIZE = {
   small: "Qwen3-0.6B-q4f16_1-MLC",
   medium: "Qwen3-1.7B-q4f16_1-MLC",
@@ -71,6 +72,15 @@ function createAppConfig(webllm, config) {
     useIndexedDBCache: (config.cacheBackend ?? "indexeddb") === "indexeddb"
   };
 }
+function describeLoadStage(text) {
+  const report = text?.trim();
+  if (!report) return "Loading model";
+  if (/from cache/i.test(report)) return "Loading cached model";
+  if (/fetch|download/i.test(report)) return "Downloading model";
+  if (/finish/i.test(report)) return "Almost ready";
+  if (/shader|gpu|compil/i.test(report)) return "Preparing GPU";
+  return report;
+}
 async function createEngine(webllm, config, initProgressCallback) {
   const appConfig = createAppConfig(webllm, config);
   if (config.workerUrl) {
@@ -121,14 +131,30 @@ function emitMetrics(usage, config) {
   } catch {
   }
 }
-function resetEngine(engine) {
+async function resetEngine(engine) {
+  await engine.resetChat();
+}
+async function resetEngineBestEffort(engine) {
   try {
-    void engine.resetChat().catch(() => {
-    });
+    await resetEngine(engine);
   } catch {
   }
 }
-function stripThinkTokens(text) {
+function usesMiniCPMModel(config) {
+  return config.modelSize?.startsWith("minicpm5-") === true;
+}
+function usesPrefilledMiniCPMThinking(config) {
+  return config.enableThinking === true && usesMiniCPMModel(config);
+}
+function resolveSystemPrompt(config) {
+  if (config.systemPrompt?.trim()) return config.systemPrompt;
+  return usesMiniCPMModel(config) ? MINICPM5_SYSTEM_PROMPT : void 0;
+}
+function stripThinkTokens(text, startsInsideThinking = false) {
+  if (startsInsideThinking && !text.includes("</think>")) return "";
+  if (startsInsideThinking && !text.includes("<think>")) {
+    text = text.slice(text.indexOf("</think>") + "</think>".length);
+  }
   let cleaned = text.replace(/<think>[\s\S]*?<\/think>/g, "");
   cleaned = cleaned.replace(/<think>[\s\S]*$/g, "");
   return cleaned.trimStart();
@@ -150,6 +176,141 @@ function buildEngineHistory(messages, maxHistoryMessages, currentUserContent) {
   return history;
 }
 
+// src/grounded-corpus.ts
+var GROUNDED_SYSTEM_PROMPT = "Answer only from the supplied context. Be concise. If the answer is not in the context, say you don't have that information on this site and suggest where to look.";
+var GROUNDED_NO_MATCH_REPLY = "I don't have information about that on this site.";
+var CONTEXT_CHARACTER_BUDGET = 2400;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "can",
+  "did",
+  "do",
+  "does",
+  "for",
+  "from",
+  "has",
+  "have",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "its",
+  "me",
+  "my",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "to",
+  "was",
+  "we",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "why",
+  "will",
+  "with",
+  "you",
+  "your"
+]);
+function normalizeTerms(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1 && !STOP_WORDS.has(term));
+}
+function chunkTerms(chunk) {
+  const source = [chunk.title, chunk.text, ...chunk.aliases ?? []].join(" ");
+  return new Set(normalizeTerms(source));
+}
+function documentFrequencies(chunks, termSets) {
+  const perDocument = /* @__PURE__ */ new Map();
+  chunks.forEach((chunk, index) => {
+    const existing = perDocument.get(chunk.document_id);
+    const target = existing ?? /* @__PURE__ */ new Set();
+    for (const term of termSets[index]) target.add(term);
+    if (!existing) perDocument.set(chunk.document_id, target);
+  });
+  const frequencies = /* @__PURE__ */ new Map();
+  for (const terms of perDocument.values()) {
+    for (const term of terms) frequencies.set(term, (frequencies.get(term) ?? 0) + 1);
+  }
+  return { frequencies, documentCount: perDocument.size };
+}
+function selectGroundedChunks(corpus, query, characterBudget = CONTEXT_CHARACTER_BUDGET) {
+  const queryTerms = new Set(normalizeTerms(query));
+  if (queryTerms.size === 0) return [];
+  const chunks = corpus.chunks ?? [];
+  const termSets = chunks.map(chunkTerms);
+  const { frequencies, documentCount } = documentFrequencies(chunks, termSets);
+  const scored = chunks.map((chunk, index) => {
+    let score = 0;
+    let matched = 0;
+    for (const term of queryTerms) {
+      if (!termSets[index].has(term)) continue;
+      matched += 1;
+      score += Math.log(1 + documentCount / (1 + (frequencies.get(term) ?? 0)));
+    }
+    return { chunk, score, matched, index };
+  }).filter((entry) => entry.matched > 0).sort((a, b) => b.score - a.score || b.matched - a.matched || a.index - b.index);
+  const selected = [];
+  let used = 0;
+  for (const entry of scored) {
+    const cost = entry.chunk.text.length;
+    if (selected.length > 0 && used + cost > characterBudget) break;
+    selected.push(entry.chunk);
+    used += cost;
+  }
+  return selected;
+}
+function buildGroundedTurn(corpus, query, characterBudget = CONTEXT_CHARACTER_BUDGET) {
+  const chunks = selectGroundedChunks(corpus, query, characterBudget);
+  if (chunks.length === 0) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const chunk of chunks) {
+    if (seen.has(chunk.document_id)) continue;
+    seen.add(chunk.document_id);
+    sources.push({ title: chunk.title, url: chunk.url });
+  }
+  return {
+    context: chunks.map((chunk) => `${chunk.title} (${chunk.url}): ${chunk.text}`).join("\n\n"),
+    sources
+  };
+}
+function buildGroundedUserContent(context, question) {
+  return `Context:
+${context}
+
+Question:
+${question}`;
+}
+async function fetchGroundedCorpus(url) {
+  const response = await fetch(url, { cache: "force-cache" });
+  if (!response.ok) throw new Error(`Failed to load grounding corpus (${response.status})`);
+  const payload = await response.json();
+  if (!Array.isArray(payload?.chunks) || payload.chunks.length === 0) {
+    throw new Error("Grounding corpus has no chunks");
+  }
+  return payload;
+}
+
 // src/use-kanha-chat.ts
 function isMemoryError(err) {
   if (!(err instanceof Error)) return false;
@@ -163,11 +324,14 @@ function useKanhaChat(config) {
   const [isThinking, setIsThinking] = react.useState(false);
   const [mode, setMode] = react.useState("detecting");
   const [loadProgress, setLoadProgress] = react.useState(0);
+  const [loadStage, setLoadStage] = react.useState("Loading model");
   const [error, setError] = react.useState(null);
   const engineRef = react.useRef(null);
   const workerRef = react.useRef(null);
   const streamTimerRef = react.useRef(null);
   const pendingTextRef = react.useRef(null);
+  const pendingSourcesRef = react.useRef(void 0);
+  const corpusRef = react.useRef(null);
   const generationRef = react.useRef(0);
   const configRef = react.useRef(config);
   configRef.current = config;
@@ -185,16 +349,24 @@ function useKanhaChat(config) {
       return;
     }
     setIsThinking(false);
+    const sources = pendingSourcesRef.current;
     setMessages((prev) => {
       const next = [...prev];
+      const message = { role: "assistant", content: cleaned, sources };
       if (next[next.length - 1]?.role === "assistant") {
-        next[next.length - 1] = { role: "assistant", content: cleaned };
+        next[next.length - 1] = message;
       } else {
-        next.push({ role: "assistant", content: cleaned });
+        next.push(message);
       }
       return next;
     });
   }, []);
+  const loadCorpus = react.useCallback((url) => {
+    if (corpusRef.current?.url !== url) {
+      corpusRef.current = { url, corpus: fetchGroundedCorpus(url) };
+    }
+    return corpusRef.current.corpus;
+  }, []);
   const scheduleAssistantMessage = react.useCallback((text) => {
     pendingTextRef.current = text;
     if (streamTimerRef.current) return;
@@ -233,11 +405,12 @@ function useKanhaChat(config) {
         return;
       }
       setMode("loading");
-      setMode("loading");
       try {
         const webllm = await import('@mlc-ai/web-llm');
         const result = await createEngine(webllm, initConfig, (report) => {
-          if (!cancelled) setLoadProgress(Math.round(report.progress * 100));
+          if (cancelled) return;
+          setLoadProgress(Math.round(report.progress * 100));
+          setLoadStage(describeLoadStage(report.text));
         });
         if (cancelled) {
           await disposeEngine(result.engine, result.worker);
@@ -306,10 +479,12 @@ function useKanhaChat(config) {
     setError(null);
     try {
       const currentConfig = configRef.current;
-      const systemMessages = currentConfig.systemPrompt ? [{ role: "system", content: currentConfig.systemPrompt }] : [];
+      let systemPrompt = resolveSystemPrompt(currentConfig);
       let engineUserContent = userText;
+      let groundedTemperature = null;
       let ragTime = 0;
       let ragContextLength = 0;
+      pendingSourcesRef.current = void 0;
       if (currentConfig.onRetrieveContext) {
         try {
           const ragStartTime = performance.now();
@@ -322,21 +497,53 @@ function useKanhaChat(config) {
         } catch (err) {
           console.error("[KanhaBot] RAG Retrieval Failed:", err);
         }
+      } else if (currentConfig.ragCorpusUrl) {
+        const ragStartTime = performance.now();
+        let corpus = null;
+        try {
+          corpus = await loadCorpus(currentConfig.ragCorpusUrl);
+        } catch (err) {
+          console.error("[KanhaBot] Grounding corpus failed to load:", err);
+        }
+        ragTime = (performance.now() - ragStartTime) / 1e3;
+        if (generationRef.current !== generation) return;
+        if (corpus) {
+          const grounded = buildGroundedTurn(corpus, userText);
+          if (!grounded) {
+            setMessages((prev) => [
+              ...prev,
+              { role: "assistant", content: GROUNDED_NO_MATCH_REPLY }
+            ]);
+            return;
+          }
+          ragContextLength = grounded.context.length;
+          engineUserContent = buildGroundedUserContent(grounded.context, userText);
+          systemPrompt = GROUNDED_SYSTEM_PROMPT;
+          groundedTemperature = 0;
+          pendingSourcesRef.current = grounded.sources;
+        }
       }
       if (generationRef.current !== generation) return;
+      const systemMessages = systemPrompt ? [{ role: "system", content: systemPrompt }] : [];
       const engineHistory = buildEngineHistory(
         allMessages,
         currentConfig.maxHistoryMessages,
         engineUserContent
       );
+      const prefilledMiniCPMThinking = usesPrefilledMiniCPMThinking(currentConfig);
+      if (usesMiniCPMModel(currentConfig)) {
+        await resetEngine(engineRef.current);
+        if (generationRef.current !== generation) return;
+      }
       const startTime = performance.now();
       let firstTokenTime = null;
       let contentChunkCount = 0;
       let completionTokens = null;
       const completion = await engineRef.current.chat.completions.create({
         messages: [...systemMessages, ...engineHistory],
-        temperature: currentConfig.temperature ?? 0.7,
+        temperature: groundedTemperature ?? currentConfig.temperature ?? 0.7,
         top_p: currentConfig.topP ?? 0.8,
+        repetition_penalty: currentConfig.repetitionPenalty ?? 1.1,
         max_tokens: currentConfig.maxTokens ?? 1024,
         stream: true,
         stream_options: { include_usage: true },
@@ -353,7 +560,7 @@ function useKanhaChat(config) {
           if (firstTokenTime === null) firstTokenTime = performance.now();
           contentChunkCount += 1;
           text += delta;
-          scheduleAssistantMessage(text);
+          scheduleAssistantMessage(stripThinkTokens(text, prefilledMiniCPMThinking));
         }
         if (chunk.usage) {
           completionTokens = chunk.usage.completion_tokens;
@@ -371,7 +578,7 @@ function useKanhaChat(config) {
             const decodeTime = firstTokenTime ? (endTime - firstTokenTime) / 1e3 : 0;
             const tps = decodeTime > 0 ? Math.max(0, outputTokens - 1) / decodeTime : 0;
             const totalTime = (endTime - startTime) / 1e3;
-            const ragStatsLog = currentConfig.onRetrieveContext ? `RAG Retrieval Time: ${ragTime.toFixed(3)}s
+            const ragStatsLog = ragContextLength > 0 ? `RAG Retrieval Time: ${ragTime.toFixed(3)}s
 RAG Context Inserted: ${ragContextLength} characters
 ` : "";
             console.info(
@@ -401,10 +608,10 @@ Output Tokens: ${outputTokens}`
         setIsThinking(false);
       }
     }
-  }, [input, mode, isLoading, messages, scheduleAssistantMessage, flushAssistantMessage]);
+  }, [input, mode, isLoading, messages, scheduleAssistantMessage, flushAssistantMessage, loadCorpus]);
   const clear = react.useCallback(() => {
     stop();
-    if (engineRef.current) resetEngine(engineRef.current);
+    if (engineRef.current) void resetEngineBestEffort(engineRef.current);
     setMessages([]);
     setError(null);
   }, [stop]);
@@ -416,6 +623,7 @@ Output Tokens: ${outputTokens}`
     isThinking,
     mode,
     loadProgress,
+    loadStage,
     error,
     send,
     stop,
@@ -607,6 +815,27 @@ function progressBarFill(progress, primaryColor) {
     transition: "width 0.3s ease"
   };
 }
+var sourcesContainerStyle = {
+  display: "flex",
+  flexWrap: "wrap",
+  gap: 6,
+  marginTop: 8,
+  paddingTop: 8,
+  borderTop: "1px solid #f0f1f2"
+};
+var sourceLinkStyle = {
+  fontSize: 11,
+  lineHeight: 1.4,
+  color: "#4b5563",
+  textDecoration: "none",
+  border: "1px solid #e5e7eb",
+  borderRadius: 999,
+  padding: "2px 8px",
+  maxWidth: "100%",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+};
 var ChatIcon = () => /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" }) });
 var CloseIcon = () => /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
   /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
@@ -645,6 +874,7 @@ function KanhaBot({
   systemPrompt,
   temperature,
   topP,
+  repetitionPenalty,
   maxTokens,
   enableThinking,
   maxHistoryMessages,
@@ -659,7 +889,8 @@ function KanhaBot({
   suggestions = [],
   theme = {},
   onRetrieveContext,
-  ragPromptTemplate
+  ragPromptTemplate,
+  ragCorpusUrl
 }) {
   const primaryColor = theme.primaryColor ?? "#0d9488";
   const position = theme.position ?? "bottom-right";
@@ -671,6 +902,7 @@ function KanhaBot({
     isThinking,
     mode,
     loadProgress,
+    loadStage,
     error,
     send,
     clear
@@ -681,6 +913,7 @@ function KanhaBot({
     systemPrompt,
     temperature,
     topP,
+    repetitionPenalty,
     maxTokens,
     enableThinking,
     maxHistoryMessages,
@@ -691,8 +924,10 @@ function KanhaBot({
     contextWindowSize,
     minRamGb,
     onRetrieveContext,
-    ragPromptTemplate
+    ragPromptTemplate,
+    ragCorpusUrl
   });
+  const loadingLabel = `${loadStage} (${loadProgress}%)`;
   const [isOpen, setIsOpen] = react.useState(false);
   const messagesEndRef = react.useRef(null);
   const textareaRef = react.useRef(null);
@@ -721,7 +956,7 @@ function KanhaBot({
       /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { ...headerStyle, background: primaryColor }, children: [
         /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
           /* @__PURE__ */ jsxRuntime.jsx("p", { style: headerTitleStyle, children: botName }),
-          /* @__PURE__ */ jsxRuntime.jsx("p", { style: headerSubtitleStyle, children: isReady ? welcomeMessage : mode === "loading" ? `Loading AI model (${loadProgress}%)` : mode === "error" ? "Failed to load" : "Detecting capabilities..." }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { style: headerSubtitleStyle, children: isReady ? welcomeMessage : mode === "loading" ? loadingLabel : mode === "error" ? "Failed to load" : "Detecting capabilities..." }),
           mode === "loading" && /* @__PURE__ */ jsxRuntime.jsx("div", { style: progressBarContainer, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: progressBarFill(loadProgress, "#fff") }) })
         ] }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", gap: 4 }, children: [
@@ -753,11 +988,7 @@ function KanhaBot({
         )) })
       ] }) : mode === "loading" ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
         /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: 32 }),
-        /* @__PURE__ */ jsxRuntime.jsxs("p", { style: { marginTop: 8 }, children: [
-          "Loading AI model (",
-          loadProgress,
-          "%)"
-        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { style: { marginTop: 8 }, children: loadingLabel }),
         /* @__PURE__ */ jsxRuntime.jsx("p", { style: { fontSize: 12, marginTop: 4 }, children: "First load takes about a minute" })
       ] }) : mode === "error" ? /* @__PURE__ */ jsxRuntime.jsx("p", { children: error }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
         /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: 32 }),
@@ -770,7 +1001,21 @@ function KanhaBot({
               display: "flex",
               justifyContent: msg.role === "user" ? "flex-end" : "flex-start"
             },
-            children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: msg.role === "user" ? userBubbleStyle(primaryColor) : assistantBubbleStyle, children: msg.role === "assistant" ? /* @__PURE__ */ jsxRuntime.jsx(ReactMarkdown__default.default, { children: msg.content }) : /* @__PURE__ */ jsxRuntime.jsx("span", { style: { whiteSpace: "pre-wrap" }, children: msg.content }) })
+            children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: msg.role === "user" ? userBubbleStyle(primaryColor) : assistantBubbleStyle, children: msg.role === "assistant" ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(ReactMarkdown__default.default, { children: msg.content }),
+              msg.sources && msg.sources.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { style: sourcesContainerStyle, children: msg.sources.map((source) => /* @__PURE__ */ jsxRuntime.jsx(
+                "a",
+                {
+                  href: source.url,
+                  target: "_blank",
+                  rel: "noopener",
+                  title: source.url,
+                  style: sourceLinkStyle,
+                  children: source.title
+                },
+                source.url
+              )) })
+            ] }) : /* @__PURE__ */ jsxRuntime.jsx("span", { style: { whiteSpace: "pre-wrap" }, children: msg.content }) })
           },
           i
         )),