bunnyquery 1.7.0 → 1.8.1

package/src/engine/session.ts

@@ -39,7 +39,8 @@ import { windowedIndexingEnabled } from './config';
 import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, getErrorMessage } from './errors';
 import { buildBoundedChatMessages } from './budget';
 import { createInlineLinkRegex } from './links';
-import { mapHistoryListToMessages, extractLastUserTextFromRequest } from './history';
+import { mapHistoryListToMessages, extractLastUserTextFromRequest, isIndexingRequestText, parseIndexingRequestText } 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';
@@ -48,6 +49,16 @@ function sleep(ms: number): Promise<void> {
 	return new Promise(function (r) { setTimeout(r, ms); });
 }
 
+// How many live items one look at the background-indexing queue asks for. The
+// queue is FIFO per user, so a healthy chain has one running plus at most a
+// couple queued; the cap only bounds a pathological backlog.
+const WORKER_PASS_ADOPT_LIMIT = 20;
+// Delays before each look (the first is immediate). More than one because the
+// worker writes the next pass's row a few milliseconds AFTER it resolves the
+// current one, so a look that wins that race sees an empty queue for a chain
+// that is still alive. Fixed and finite: this must never become a poll.
+const WORKER_PASS_ADOPT_ATTEMPTS = [0, 2000, 6000];
+
 // requestAnimationFrame / high-res clock, reached through globalThis so the
 // engine stays DOM-free at the type level (and degrades gracefully in non-DOM
 // / test environments where these globals are absent).
@@ -477,7 +488,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 +511,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 +553,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 +609,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 +630,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 +690,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 +700,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 +1017,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 +1091,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;
@@ -1097,8 +1121,29 @@ export class ChatSession {
 
 	// --- background-task resolution + drain -------------------------------
 	handleHistoryItemResolution(itemId: string, response: any, platform: string): void {
+		// Which file this turn was indexing, read BEFORE the resolution rewrites the
+		// bubbles. Every settling turn funnels through here — the bg drain's own
+		// poll, the history poll, and agent.vue's forked history poll, which calls
+		// straight into this method — so hooking the chain follow-up here is what
+		// makes it work in both clients without either of them forking a call site.
+		var indexRef = this._indexRefOfItem(itemId);
 		this.applyHistoryItemResolution(itemId, response, platform);
 		this.promoteNextBgQueuedToRunning();
+		// A worker-driven chain has no client-side record of its next pass, so a
+		// settling pass is the only moment there is to go looking for one.
+		if (indexRef) this._followWorkerIndexingChain(indexRef.name, indexRef.mime);
+	}
+
+	/** The file an already-rendered background pass is about, off its request
+	 *  bubble. Null for an ordinary turn, which is most of them. */
+	private _indexRefOfItem(itemId: string): { name?: string; mime?: string } | null {
+		if (!itemId) return null;
+		for (var i = 0; i < this.state.messages.length; i++) {
+			var m = this.state.messages[i];
+			if (m._serverItemId !== itemId || m.role !== 'user' || !m.isBackgroundTask) continue;
+			return m._indexFile || null;
+		}
+		return null;
 	}
 
 	applyHistoryItemResolution(itemId: string, response: any, platform: string): void {
@@ -1156,6 +1201,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;
@@ -1246,6 +1292,175 @@ export class ChatSession {
 		});
 	}
 
+	/**
+	 * True when the WORKER, not this client, drives the rest of this file's chain.
+	 * The mirror image of the early returns in maybeResumeIndexing: whatever that
+	 * refuses to continue is exactly what nothing client-side is tracking.
+	 */
+	private _isWorkerDrivenIndexing(filename?: string, mime?: string): boolean {
+		if (!isPagedReadFile(filename, mime)) return false;
+		if (isImageVisionFile(filename, mime)) return true;
+		return windowedIndexingEnabled() && isWindowedReadFile(filename, mime);
+	}
+
+	/**
+	 * Pick up indexing passes the WORKER minted, which no client ever dispatched.
+	 *
+	 * For a PDF (and for text/grid when windowed indexing is on) the worker writes
+	 * pass N+1's row itself, inside pass N's invocation, right after saving pass
+	 * N's result. That row reaches this client through nothing at all: it is not in
+	 * bgTaskQueue (the client never asked for it) and it is not in state.messages
+	 * (only a first-page history load maps it in, which happens on mount, project
+	 * switch or tab return). So between two worker passes every pass the client
+	 * knows about is settled, and the collapsed row renders "Indexed  N passes"
+	 * with no spinner and no Stop, for a file that is still being read. A user who
+	 * believes that then asks questions against a half-indexed file — which is what
+	 * this exists to prevent.
+	 *
+	 * So when a background indexing pass settles, ask the bg queue what is still
+	 * unresolved on it and adopt anything unknown as an ordinary BgTaskEntry.
+	 * drainBgTaskQueue then treats it exactly like a pass this client dispatched:
+	 * same bubble, same `_indexFile` (so it joins the file's collapsed row), same
+	 * poll — and that poll settling runs this again, so the chain is followed to
+	 * its end. `status`-scoped so the reply carries the live items only, never a
+	 * page of finished ones with their bodies.
+	 *
+	 * Termination: the only trigger is a pass SETTLING, which happens once per
+	 * pass. An adopted item that is still running is not re-adopted (its id is
+	 * already polled), and when the queue holds nothing unknown the chain stops on
+	 * its own. Nothing here is periodic — a timer that re-reads history is the
+	 * shape that previously looped fetchHistoryPage after an already-DONE index.
+	 */
+	private _adoptingWorkerPasses = false;
+	private _adoptWorkerIndexingPasses(attempt: number): void {
+		var self = this;
+		// One in flight at a time. The query is queue-WIDE, so a second file's pass
+		// settling in the same moment is covered by the query already running.
+		if (this._adoptingWorkerPasses) return;
+		var id = this.host.getIdentity();
+		var platform = id.platform;
+		if (!id.serviceId || (platform !== 'claude' && platform !== 'openai')) return;
+		if (this.isPollingPaused() || !this.host.isViewMounted()) return;
+		var svcId = id.serviceId, owner = id.owner;
+		var queue = (id.userId || id.serviceId) + BG_INDEXING_QUEUE_SUFFIX;
+		var ask = function (status: 'pending' | 'running') {
+			return Promise.resolve(getChatHistory(
+				{ service: svcId, owner: owner, platform: platform as 'claude' | 'openai', queue: queue, status: status },
+				{ limit: WORKER_PASS_ADOPT_LIMIT },
+			)).catch(function () { return null; });
+		};
+		this._adoptingWorkerPasses = true;
+		Promise.all([ask('running'), ask('pending')]).then(function (results: any[]) {
+			self._adoptingWorkerPasses = false;
+			// The chat may have changed under the query; adopting into another
+			// project's session is the cross-project bubble leak all over again.
+			var now = self.host.getIdentity();
+			if (now.serviceId !== svcId || now.platform !== platform) return;
+			if (!self.host.isViewMounted()) return;
+			var adoptedIds: string[] = [];
+			for (var ri = 0; ri < results.length; ri++) {
+				var list = results[ri] && Array.isArray(results[ri].list) ? results[ri].list : [];
+				for (var i = 0; i < list.length; i++) {
+					if (self._adoptWorkerIndexingItem(list[i], svcId, platform as 'claude' | 'openai')) adoptedIds.push(list[i].id);
+				}
+			}
+			if (adoptedIds.length) {
+				self.drainBgTaskQueue();
+				// Only an item the drain KEPT means the chain is still going. One it
+				// threw straight back out is not progress and must not end the ladder:
+				// the status index is eventually consistent, so a look taken the
+				// instant a pass settles can still report that pass as running, and a
+				// pass belonging to a file the user stopped is dropped on sight. Both
+				// used to read as "found the next pass", which ended the search for a
+				// pass that had not been written yet.
+				if (self._isTrackingAny(adoptedIds)) return;
+			}
+			// Nothing yet. The worker writes pass N+1 a few milliseconds AFTER it
+			// flips pass N to resolved, so a poll that lands in that gap sees an
+			// empty queue for a chain that is very much alive — and with no pass
+			// left to settle, nothing would ever ask again. Look once or twice more
+			// before believing the file is finished.
+			if (attempt + 1 >= WORKER_PASS_ADOPT_ATTEMPTS.length) return;
+			setTimeout(function () {
+				var later = self.host.getIdentity();
+				if (later.serviceId !== svcId || later.platform !== platform) return;
+				if (self.isPollingPaused() || !self.host.isViewMounted()) return;
+				self._adoptWorkerIndexingPasses(attempt + 1);
+			}, WORKER_PASS_ADOPT_ATTEMPTS[attempt + 1]);
+		}, function () { self._adoptingWorkerPasses = false; });
+	}
+
+	/** Any of these ids still queued or still polled, i.e. surviving work. */
+	private _isTrackingAny(ids: string[]): boolean {
+		for (var i = 0; i < ids.length; i++) {
+			if (this.historyItemPolls.has(ids[i])) return true;
+			for (var q = 0; q < this.bgTaskQueue.length; q++) {
+				if (this.bgTaskQueue[q].id === ids[i]) return true;
+			}
+		}
+		return false;
+	}
+
+	/** One live bg-queue item -> a BgTaskEntry, if it is an indexing pass this
+	 *  client is not already tracking. Returns whether it was adopted. */
+	private _adoptWorkerIndexingItem(item: any, svcId: string, platform: 'claude' | 'openai'): boolean {
+		if (!item || typeof item.id !== 'string' || !item.id) return false;
+		if (item.status !== 'pending' && item.status !== 'running') return false;
+		if (typeof item.poll !== 'function') return false;
+		// Already known: a pass this client dispatched, or one adopted earlier that
+		// has not settled yet. Adopting twice would stack a second poll on one item.
+		if (this.historyItemPolls.has(item.id)) return false;
+		for (var q = 0; q < this.bgTaskQueue.length; q++) {
+			if (this.bgTaskQueue[q].id === item.id) return false;
+		}
+		// Already SETTLED here. The status index is eventually consistent, so the
+		// pass that just finished can still come back as running; re-adopting it
+		// would re-poll a dead item and, worse, read as the chain continuing.
+		for (var m = 0; m < this.state.messages.length; m++) {
+			var msg = this.state.messages[m];
+			if (msg._serverItemId !== item.id) continue;
+			if (!(msg.isPending || msg.isPendingInProcess || msg.isPendingQueued)) return false;
+		}
+		// The bg queue also carries ordinary chats routed onto it (_isOnBgQueue), and
+		// both platforms share one queue name, so check the shape as well: a claude
+		// request body has `messages`, an openai one has `input`. Adopting the other
+		// platform's item would poll it against this platform's url.
+		var body = item.request_body;
+		if (!body || typeof body !== 'object') return false;
+		if (platform === 'claude' ? !Array.isArray((body as any).messages) : !Array.isArray((body as any).input)) return false;
+		var userText = extractLastUserTextFromRequest(body);
+		if (!isIndexingRequestText(userText)) return false;
+		var ref = parseIndexingRequestText(userText);
+		if (!ref || !ref.name) return false;
+		// Only chains the worker drives. A client-driven file is already tracked by
+		// the entry that dispatched it, and adopting a copy of it would hand
+		// maybeResumeIndexing an entry whose resumePass no longer counts that
+		// chain's passes — which is the cap that stops it running forever.
+		if (!this._isWorkerDrivenIndexing(ref.name, ref.mime)) return false;
+		this.bgTaskQueue.push({
+			serviceId: svcId,
+			platform: platform,
+			id: item.id,
+			filename: ref.name,
+			storagePath: ref.path,
+			mime: ref.mime,
+			size: ref.size,
+			status: item.status === 'running' ? 'running' : 'pending',
+			poll: item.poll,
+			// Drives the "(continuing)" label and marks this as a continuation for
+			// _applyIndexCancellations, which must not read a CONTINUE pass as the
+			// fresh first pass that lifts a stop.
+			resumePass: ref.continued ? 1 : 0,
+		});
+		return true;
+	}
+
+	/** Follow the chain on from a background indexing pass that just settled. */
+	private _followWorkerIndexingChain(filename?: string, mime?: string): void {
+		if (!this._isWorkerDrivenIndexing(filename, mime)) return;
+		this._adoptWorkerIndexingPasses(0);
+	}
+
 	/** Best-effort server-side cancel of a bg-queue item that has no bubble (so
 	 *  cancelQueuedMessage, which drives one, has nothing to act on). */
 	private _cancelServerItem(serverId: string): void {
@@ -1470,8 +1685,7 @@ export class ChatSession {
 			var chatList = history && Array.isArray(history.list) ? history.list : [];
 			chatList.forEach(function (item: any) {
 				if (isBgIndexingQueue(item.queue_name)) {
-					var userText = extractLastUserTextFromRequest(item.request_body);
-					if (typeof userText === 'string' && (userText.indexOf('A new file has just been uploaded') === 0 || userText.indexOf('CONTINUE indexing') === 0)) item._isBgTask = true;
+					if (isIndexingRequestText(extractLastUserTextFromRequest(item.request_body))) item._isBgTask = true;
 					else item._isOnBgQueue = true;
 				}
 			});

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;