bunnyquery 1.7.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunnyquery",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Embeddable BunnyQuery AI chat widget + its framework-agnostic chat engine",
   "main": "bunnyquery.js",
   "exports": {

package/src/engine/history.ts

@@ -64,6 +64,13 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 		var assistantText = isPending ? '' : ((extractAssistantText(response) || '').trim() || '');
 		var isErrorResponse = !isPending && (isFailed || isErrorResponseBody(response));
 		var serverItemId = item && typeof item.id === 'string' && item.id ? item.id : undefined;
+		// A USER bubble shows when the request was made (`created`); an ASSISTANT
+		// bubble shows when its response landed (`updated`). Fall back to the other
+		// if one is missing (older records only carried `updated`).
+		var createdTs = Number(item && item.created);
+		var updatedTs = Number(item && item.updated);
+		var userTs = isFinite(createdTs) && createdTs > 0 ? createdTs : (isFinite(updatedTs) && updatedTs > 0 ? updatedTs : undefined);
+		var replyTs = isFinite(updatedTs) && updatedTs > 0 ? updatedTs : (isFinite(createdTs) && createdTs > 0 ? createdTs : undefined);
 
 		if (userText) {
 			var displayContent;
@@ -110,6 +117,7 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			if (indexFile) userMsg._indexFile = indexFile;
 			if (item._isOnBgQueue) userMsg._useBgQueue = true;
 			if (serverItemId !== undefined) userMsg._serverItemId = serverItemId;
+			if (userTs !== undefined) userMsg._ts = userTs;
 			mapped.push(userMsg);
 		}
 		if (isCancelledItem) { /* no assistant bubble */ }
@@ -123,6 +131,7 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			var em: any = { role: 'assistant', content: getErrorMessage(response), isError: true };
 			if (item._isBgTask) em.isBackgroundTask = true;
 			if (serverItemId !== undefined) em._serverItemId = serverItemId;
+			if (replyTs !== undefined) em._ts = replyTs;
 			mapped.push(em);
 		} else if (assistantText) {
 			// Safe db-only sanitize (forAssistant) so a volatile db url the model
@@ -130,6 +139,7 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			var okm: any = { role: 'assistant', content: sanitizeAttachmentLinksForHistory(assistantText, opts.serviceId, true) };
 			if (item._isBgTask) okm.isBackgroundTask = true;
 			if (serverItemId !== undefined) okm._serverItemId = serverItemId;
+			if (replyTs !== undefined) okm._ts = replyTs;
 			mapped.push(okm);
 		}
 	});

package/src/engine/host.ts

@@ -67,6 +67,12 @@ export interface ChatMessage {
 	_localId?: string;
 	_cancelling?: boolean;
 	_cancelError?: string;
+	/** Epoch ms shown as small text under the bubble. From the request history a
+	 *  USER bubble carries the request's `created` time and an ASSISTANT bubble the
+	 *  `updated` (response) time; a live bubble is stamped with the wall clock when
+	 *  it is created, then reconciled to the server value on the next history load.
+	 *  Absent while a turn is still pending, so no time shows on a "Thinking" bubble. */
+	_ts?: number;
 	// History cache key (`serviceId#platform`) this bubble was created under.
 	// Stamped on LOCALLY-created bubbles only (the optimistic user message and
 	// its "Thinking..." placeholder); server-mapped bubbles are identified by

package/src/engine/index.ts

@@ -46,6 +46,7 @@ export * from './prompts';
 export { getErrorMessage, isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError } from './errors';
 export * from './budget';
 export * from './links';
+export * from './time';
 export {
 	filterListByClearHorizon,
 	normalizeTextContent,

package/src/engine/indexing_groups.ts

@@ -7,12 +7,34 @@
  * repeating forever, and any real question the user asks in between gets buried.
  *
  * buildChatDisplayList turns the flat message array into a DISPLAY list in which
- * every message belonging to one file (however far apart they sit, and whatever
- * else is interleaved between them) is represented by a single group entry,
- * rendered at the position of that file's NEWEST turn. Newest, not oldest, so:
- *   - a running index sits at the bottom, where the activity is, and
- *   - paging older history in never moves a row that is already on screen
- *     (older passes simply join the group they already belong to).
+ * every message belonging to one run of one file (however far apart the passes
+ * sit, and whatever else is interleaved between them) is represented by a single
+ * group entry, rendered at the position of that run's FIRST loaded pass.
+ *
+ * First, not newest. The message array is ordered by request CREATION time, and
+ * a run's later passes are created one at a time as the previous one resolves —
+ * by the client for the paged text path, and by the WORKER itself for the
+ * rendered-page (PDF) path, which the client only learns about on its next
+ * first-page history fetch. So a pass is routinely created minutes after the
+ * upload, on a queue that runs in parallel with the foreground chat. Anchoring
+ * at the newest pass meant one such late pass dragged the whole run — every
+ * earlier pass with it — below any question the user had asked in the meantime,
+ * and made a run that had visibly finished before the question render after it.
+ * Anchoring at the first pass puts the row where the run actually began, which
+ * is a position no later pass can change:
+ *   - a new pass never relocates the row, so nothing under the reader shifts;
+ *   - a question asked after the upload always renders below the row, which is
+ *     the order it happened in.
+ * The cost is that a long-running index does not follow the conversation to the
+ * bottom: once the user has chatted past the upload, the spinner and the Stop
+ * button sit above their newest turns. That is a scroll away, and the row no
+ * longer lies about when the work started.
+ *
+ * Paging older history is the one thing that CAN move the row: an older page
+ * carrying earlier passes of a run already on screen moves it up into that page.
+ * That happens at most once per run, only for a run whose start was never
+ * loaded (`mayHaveOlder`), and it is the same event that already re-derives
+ * `runKey` — so the view treats it as a new row either way.
  *
  * The group deliberately reports no authoritative pass TOTAL. History is paged
  * newest-first, so any total computed from loaded messages is a lower bound that
@@ -37,9 +59,10 @@ export type IndexingGroup = {
 	 *  Monday and re-indexed on Wednesday is two runs, and collapsing them into
 	 *  one row erased Monday's from Monday's place in the conversation, claimed
 	 *  its passes for Wednesday, and let Monday's failure be overwritten by
-	 *  Wednesday's success. Numbered from the NEWEST run backwards (`#0` is the
-	 *  newest) so paging in older history never renames a row already on screen.
-	 *  This is the render key and the expansion key. */
+	 *  Wednesday's success. Named after the run's FIRST loaded pass (see where it
+	 *  is assigned below), so passes appended to the run and other runs appearing
+	 *  on either side of it never rename a row already on screen. This is the
+	 *  render key and the expansion key. */
 	runKey: string;
 	name: string;
 	path?: string;
@@ -65,8 +88,16 @@ export type IndexingGroup = {
 	/** The file's first pass is not among the loaded messages, so earlier passes
 	 *  exist in history that has not been paged in yet. */
 	mayHaveOlder: boolean;
-	/** Position in the source array this collapsed row renders at. */
+	/** Position in the source array this collapsed row renders at: the index of
+	 *  the run's FIRST loaded pass (see the file docstring for why not the last). */
 	anchorIndex: number;
+	/** Identity of the turn at `anchorIndex` — its server item id, or its local id
+	 *  while it has none, or `''` when it has neither. The views stamp this on the
+	 *  row (`data-row-pos`) so the scroll anchor can tell a row that RELOCATED (an
+	 *  older page moved the run's start) from one that merely gained a pass. They
+	 *  must not re-derive it from `members`: which member the row renders at is
+	 *  this module's decision, and the two silently disagreed once already. */
+	anchorId: string;
 };
 
 export type DisplayEntry =
@@ -230,7 +261,10 @@ export function buildChatDisplayList(
 				cancellableIds: [],
 				cancelling: false,
 				mayHaveOlder: false,
+				// The run's first loaded pass, and never re-stamped: see the file
+				// docstring. `anchorId` is filled in once every member is known.
 				anchorIndex: i,
+				anchorId: '',
 			};
 			order.push(runId);
 		}
@@ -246,7 +280,6 @@ export function buildChatDisplayList(
 			g.passCount++;
 		}
 		g.members.push({ msg: msg, index: i });
-		g.anchorIndex = i;
 		runOfIndex[i] = runId;
 		if (msg._serverItemId) runByItemId[msg._serverItemId] = runId;
 		if (ref && ref.name) keyByName[ref.name] = g.key;
@@ -334,6 +367,12 @@ export function buildChatDisplayList(
 			if (pref && !pref.continued) { sawFirstPass = true; break; }
 		}
 		grp.mayHaveOlder = !sawFirstPass && hasMoreHistory;
+		// Where the row renders, and WHICH turn that is. Derived from the same
+		// member so the two can never drift apart; a group always has a member
+		// (it is created by the first one).
+		var anchor = grp.members[0];
+		grp.anchorIndex = anchor.index;
+		grp.anchorId = anchor.msg._serverItemId || anchor.msg._localId || '';
 	}
 
 	var out: DisplayEntry[] = [];

package/src/engine/links.ts

@@ -183,6 +183,33 @@ export function repairUrlWhitespace(href: string): string {
 	return href.trim().replace(/\s/g, '%20');
 }
 
+/**
+ * A model reproducing a URL sometimes HTML-escapes its `&` query separators as
+ * `&` (or the numeric `&` / `&`). Left in the href that escaping
+ * survives the client's own escapeAttr -> v-html/innerHTML decode round-trip and
+ * reaches the browser LITERALLY, so a presigned S3 URL is navigated with its
+ * parameters named `amp;Signature`, `amp;Expires`, `amp;response-content-type`,
+ * ... — the real params vanish, the signature can't be located, and S3 rejects
+ * it (the "링크가 안되" dead export link). Undo just that entity escaping.
+ *
+ * This is a no-op on a clean URL: a valid link carries a raw `&` between params
+ * and percent-encodes (`%26`) any literal ampersand that is data, so a real URL
+ * never contains `&` to begin with. Mirrors repairUrlWhitespace: it repairs
+ * model damage, not the URL. The loop collapses a doubly-escaped `&` too.
+ */
+export function repairUrlEntities(href: string): string {
+	if (!href || href.indexOf('&') === -1) return href;
+	var out = href, prev = '';
+	while (out !== prev) {
+		prev = out;
+		out = out
+			.replace(/&/gi, '&')
+			.replace(/&#0*38;/g, '&')
+			.replace(/&#x0*26;/gi, '&');
+	}
+	return out;
+}
+
 /**
  * Trim punctuation and unmatched wrappers that cling to a token in prose.
  * `src::a/b.pdf).` -> `src::a/b.pdf`, while a balanced `file (v2).pdf` is kept.
@@ -280,8 +307,11 @@ export function classifyInlineLink(
 		// source into the storage-path branch, where it became a chip pointing at
 		// this project for someone else's file.
 		if (srcIsUrl && !isDbHost(rawPath) && !readExpiredAttachmentHref(rawPath)) {
+			// decode any model-introduced `&` in the URL (tail stays keyed on
+			// the raw match length, so it is left untouched)
+			var srcUrl = repairUrlEntities(rawPath);
 			return {
-				part: { type: 'link', label: truncateLabelForDisplay(rawPath), fullLabel: rawPath, href: rawPath, expired: false },
+				part: { type: 'link', label: truncateLabelForDisplay(srcUrl), fullLabel: srcUrl, href: srcUrl, expired: false },
 				tail: tail,
 			};
 		}
@@ -337,6 +367,10 @@ export function classifyInlineLink(
 	// [label](url) and bare urls.
 	var originalHref = g3 || g6 || '';
 	if (!originalHref) return null;
+	// A model that reproduces the URL may have HTML-escaped its `&` separators;
+	// decode them now so every downstream check and the final href see a clean
+	// URL (otherwise a presigned link navigates with `&` and 403s).
+	originalHref = repairUrlEntities(originalHref);
 	// A bare url swallows the punctuation that ends the sentence it sits in, so
 	// `see https://host/a.pdf.` linked to `a.pdf.` and 404'd. Trim it and hand the
 	// trimmed text back as `tail`, exactly as the src:: branch does.

package/src/engine/prompts/chat_system_prompt.ts

@@ -26,6 +26,9 @@ export function buildChatSystemPrompt(params: ChatSystemPromptParams): string {
 You are a dedicated assistant for the project ID: "${formattedServiceId}".
 Scope: Only answer questions about this project and its data. Do not answer questions about other projects or topics unrelated to this project. When the user refers to "my database", "my data", or "my files", treat those as references to this project's database and file storage.
 Knowledge lookup: Before saying you don't know or that something isn't in the chat history, ALWAYS query this project's database through the available MCP tools to look for the answer. The user's data is the source of truth - the chat transcript is not. Only respond with "I don't know" or "I couldn't find that" after you have actually searched the project's data and come back empty.
+Complete answers over stored data: The database holds one record per spreadsheet row, and each uploaded file becomes many records that usually share a table. So a question about the data almost always spans many records across several files. For any request that counts, sums, totals, lists every match, compares across records, finds which one, or asks whether something is present or ABSENT (for example "how many", "total spent", "which card", "is there any", "없어?", "하나도 없나?"), you MUST read the COMPLETE matching set before answering. Query with fetch_all set to true, or page through getToolResponsePage until pagination.complete is true, across EVERY relevant table and EVERY relevant file. A single default query returns only the first page (about 50 records). That is a SAMPLE. Never treat it as the whole dataset.
+Never assert absence from a partial read. Do not say "there is no X", "none", "not found", or "아니요, 없습니다" until a complete scan has come back empty. If you have not finished scanning every relevant table and file, keep querying instead of guessing. A confident "no" that later turns out wrong is worse than telling the user you are still checking.
+Embedded values: a search term is often stored inside a larger string. A merchant "GODADDY" appears as "DNH*GODADDY#4070277042", and a card as "4140****2941". Server-side index and tag filters match only exact values or leading prefixes, not substrings, so filtering on such a field silently drops rows. When the value you are looking for may be embedded, do not trust a narrow filter to be complete. Fetch the full set with fetch_all and match the substring yourself.
 File attachments: When a user message contains an "Attached files:" section with markdown links, those links point to short-lived signed URLs in this project's db storage and will expire.
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
 - Most attached files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY had their text extracted on the server and inlined in the same message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read it directly there and do NOT call web_fetch for those files. A "[skapi: ...]" note in that block means the file could not be extracted.

package/src/engine/session.ts

@@ -40,6 +40,7 @@ import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, ge
 import { buildBoundedChatMessages } from './budget';
 import { createInlineLinkRegex } from './links';
 import { mapHistoryListToMessages, extractLastUserTextFromRequest } from './history';
+import { wallClockNow } from './time';
 import { parseAttachmentContent } from './attachment_parsers';
 import type { ChatHost, ChatState, ChatMessage, PinnedDispatchContext } from './host';
 import type { IndexingGroup } from './indexing_groups';
@@ -477,7 +478,7 @@ export class ChatSession {
 			var offExisting = this.aiChatHistoryCache[key] || { messages: [], endOfList: false, startKeyHistory: [] };
 			this.aiChatHistoryCache[key] = {
 				messages: offExisting.messages.concat([
-					{ role: 'user', content: composed, _ownerKey: key },
+					{ role: 'user', content: composed, _ownerKey: key, _ts: wallClockNow() },
 					{ role: 'assistant', content: '', isPending: true, isPendingInProcess: true, _ownerKey: key },
 				]),
 				endOfList: offExisting.endOfList,
@@ -500,7 +501,7 @@ export class ChatSession {
 				platform: aiPlatform, model: aiModel, systemPrompt: systemPrompt, serviceId: id.serviceId,
 				history: resolvedHistory.concat([{ role: 'user', content: llmComposed }]),
 			});
-			var queuedBubble: ChatMessage = { role: 'user', content: composed, isPendingQueued: true, isSendingToServer: true };
+			var queuedBubble: ChatMessage = { role: 'user', content: composed, isPendingQueued: true, isSendingToServer: true, _ts: wallClockNow() };
 			if (key) queuedBubble._ownerKey = key;
 			if (useBgQueue) queuedBubble._useBgQueue = true;
 			this.state.messages.push(queuedBubble);
@@ -542,7 +543,7 @@ export class ChatSession {
 		// view unmount), then rendered from the cache via typewriteLatestReply. A
 		// later resumePendingRequest() re-renders it if the view remounted while the
 		// request was still in flight.
-		this.state.messages.push({ role: 'user', content: composed, ...(key ? { _ownerKey: key } : {}) });
+		this.state.messages.push({ role: 'user', content: composed, _ts: wallClockNow(), ...(key ? { _ownerKey: key } : {}) });
 		this.state.messages.push({ role: 'assistant', content: '', isPending: true, isPendingInProcess: true, ...(key ? { _ownerKey: key } : {}) });
 		this.host.notify(); this.updateHistoryCache(); this.state.sending = true; this.host.scrollToBottom(true);
 
@@ -598,6 +599,7 @@ export class ChatSession {
 		var existing = this.state.messages[nextIdx];
 		var promoted: ChatMessage = { role: 'user', content: existing.content, isPendingInProcess: true, isBackgroundTask: true };
 		if (existing._indexFile) promoted._indexFile = existing._indexFile;
+		if (existing._ts !== undefined) promoted._ts = existing._ts;
 		if (existing._serverItemId !== undefined) promoted._serverItemId = existing._serverItemId;
 		if (existing._ownerKey !== undefined) promoted._ownerKey = existing._ownerKey;
 		this.state.messages[nextIdx] = promoted;
@@ -618,6 +620,7 @@ export class ChatSession {
 		var promoted: ChatMessage = { role: 'user', content: existing.content, isPendingInProcess: true };
 		if (existing.isBackgroundTask) promoted.isBackgroundTask = true;
 		if (existing._indexFile) promoted._indexFile = existing._indexFile;
+		if (existing._ts !== undefined) promoted._ts = existing._ts;
 		if (existing._serverItemId !== undefined) promoted._serverItemId = existing._serverItemId;
 		if (existing._ownerKey !== undefined) promoted._ownerKey = existing._ownerKey;
 		if (existing.isSendingToServer) promoted.isSendingToServer = true;
@@ -677,6 +680,7 @@ export class ChatSession {
 			var repl: ChatMessage = { role: 'user', content: exist.content };
 			if (exist._serverItemId !== undefined) repl._serverItemId = exist._serverItemId;
 			if (exist._ownerKey !== undefined) repl._ownerKey = exist._ownerKey;
+			if (exist._ts !== undefined) repl._ts = exist._ts;
 			this.state.messages[userIdx] = repl;
 		}
 		var thinkingIdx = userIdx >= 0
@@ -686,6 +690,9 @@ export class ChatSession {
 	}
 
 	insertAtTarget(msg: ChatMessage, targetIdx: number): void {
+		// Error/direct replies land here rather than through the typewriter, so this
+		// is where they pick up their display time.
+		if (msg && msg.role === 'assistant' && msg._ts === undefined) msg._ts = wallClockNow();
 		if (targetIdx >= 0 && this.state.messages[targetIdx] && this.state.messages[targetIdx].isPending) this.state.messages[targetIdx] = msg;
 		else if (targetIdx >= 0) this.state.messages.splice(targetIdx, 0, msg);
 		else this.state.messages.push(msg);
@@ -1000,6 +1007,12 @@ export class ChatSession {
 	private typewriterQueue: Promise<any> = Promise.resolve();
 	enqueueTypewrite(idx: number, fullText: string, localId?: string): Promise<any> {
 		var self = this;
+		// Stamp the reply bubble's display time as it starts revealing. This is the
+		// single chokepoint every typed reply (immediate, queued, and bg-resolution)
+		// passes through, so it is where a live reply gets its "when it arrived"
+		// timestamp; a history reload later replaces it with the server `updated`.
+		var target = this.state.messages[idx];
+		if (target && target._ts === undefined) target._ts = wallClockNow();
 		this.typewriterQueue = this.typewriterQueue.then(function () { return self.typewriteIntoIndex(idx, fullText, localId); });
 		return this.typewriterQueue;
 	}
@@ -1068,6 +1081,7 @@ export class ChatSession {
 		var u = this.state.messages[uIdx];
 		var cleaned: ChatMessage = { role: 'user', content: u.content, _serverItemId: itemId };
 		if (u.isBackgroundTask) cleaned.isBackgroundTask = true;
+		if (u._ts !== undefined) cleaned._ts = u._ts;
 		// Carry the file ref: it is what keeps this pass in its file's collapsed
 		// row (the label parser is only a fallback for older cached bubbles).
 		if (u._indexFile) cleaned._indexFile = u._indexFile;
@@ -1156,6 +1170,7 @@ export class ChatSession {
 		// bg-queued chat cancelling against the right queue) once the pass settles.
 		var settledUser: ChatMessage = { role: 'user', content: ex.content, _serverItemId: itemId };
 		if (ex.isBackgroundTask) settledUser.isBackgroundTask = true;
+		if (ex._ts !== undefined) settledUser._ts = ex._ts;
 		if (ex._indexFile) settledUser._indexFile = ex._indexFile;
 		if (ex._useBgQueue) settledUser._useBgQueue = true;
 		this.state.messages[userIdx] = settledUser;

package/src/engine/time.ts

@@ -0,0 +1,34 @@
+/**
+ * Chat timestamp formatting, shared so agent.vue and the widget render an
+ * identical "small text under the bubble". Pure and locale-aware: it formats a
+ * given epoch-ms value, it never reads the current time, so it stays testable and
+ * DOM-free.
+ */
+
+/** Wall-clock epoch ms. Separate from the engine's monotonic nowMs() (which is
+ *  performance.now() when available and therefore NOT epoch): a displayed
+ *  timestamp must be wall time. */
+export function wallClockNow(): number {
+	return Date.now();
+}
+
+/**
+ * "Jul 24, 2026, 3:42:07 PM" (locale-formatted). Empty string for a missing or
+ * non-finite value, so a caller can gate rendering on the result being truthy and
+ * a pending bubble (no timestamp yet) simply shows nothing.
+ */
+export function formatChatTimestamp(ms?: number): string {
+	if (typeof ms !== 'number' || !isFinite(ms) || ms <= 0) return '';
+	try {
+		return new Date(ms).toLocaleString(undefined, {
+			year: 'numeric',
+			month: 'short',
+			day: 'numeric',
+			hour: 'numeric',
+			minute: '2-digit',
+			second: '2-digit',
+		});
+	} catch (e) {
+		return '';
+	}
+}

package/styles/chat.css

@@ -76,6 +76,18 @@
     font-style: italic;
     clear: both;
 }
+/* Timestamp under a settled bubble (created for a user turn, response time for an
+   assistant turn). Muted and small so it never competes with the message. */
+.bq-msg-time {
+    display: block;
+    margin-top: 0.25rem;
+    font-size: 0.62rem;
+    line-height: 1;
+    color: var(--bq-muted);
+    opacity: 0.7;
+    clear: both;
+}
+.bq-message.is-user .bq-msg-time { text-align: right; }
 .bq-cancel-queue-btn {
     float: right;
     margin: -0.25rem -0.25rem 0.2rem 0.4rem;