bunnyquery 1.12.1 → 1.14.0

package/src/engine/session.ts

@@ -48,6 +48,7 @@ import { windowedIndexingEnabled, liveStreamingEnabled, streamRecoveryEnabled, c
 import { createSseParser, type SseParser } from './sse';
 import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, getErrorMessage, isCsrStatusEnvelope } from './errors';
 import { buildBoundedChatMessages } from './budget';
+import { extractRetrievalNote } from './retrieval_memory';
 import { createInlineLinkRegex, sanitizeAttachmentLinksForHistory } from './links';
 import { markImagePreviewStale } from './image_preview';
 import { chatCacheKey, indexScopeKey, mapHistoryListToMessages, extractLastUserTextFromRequest, isIndexingRequestText, parseIndexingRequestText, probeBgQueue, BG_PROBE_TTL_MS, getSplitChatHistory, shouldRescueInFlightMessage, adoptLocalAnswerIntoPage } from './history';
@@ -1220,6 +1221,35 @@ export class ChatSession {
 	/** Live streams by server item id. One per in-flight streamed turn. */
 	private liveStreams: { [itemId: string]: LiveStreamState } = {};
 
+	/** When skapi recorded a turn's response as having finished arriving, by server
+	 *  item id. Read off the terminal envelope of a STREAMED turn (the only settle
+	 *  that carries it, see _settleLiveStream) and used as the answer bubble's time
+	 *  in place of this browser's clock. Entries are never removed: a settle reaches
+	 *  here twice (the poll's onResponse, then the promise), and the value for an id
+	 *  cannot change. */
+	private _respondedAt: { [itemId: string]: number } = {};
+
+	private _noteRespondedAt(itemId: string, response: any): void {
+		if (!itemId || !isCsrStatusEnvelope(response)) return;
+		var at = Number(response.responded);
+		if (!isFinite(at) || at <= 0) return;
+		// Self-healing for a session built without the constructor (the engine tests
+		// drive Object.create(ChatSession.prototype)), like typewriterQueue below.
+		if (!this._respondedAt) this._respondedAt = {};
+		this._respondedAt[itemId] = at;
+	}
+
+	/** The time a live answer bubble is stamped with: when skapi received the
+	 *  response, if the settle told us, else now. "Now" is what every bubble got
+	 *  before, and it is still right for a buffered turn, whose settle hands back the
+	 *  destination's body and nothing of skapi's; a history load then replaces it
+	 *  with the server's value. */
+	private _replyStampFor(msg: ChatMessage | undefined): number {
+		var id = msg ? msg._serverItemId : undefined;
+		var at = (typeof id === 'string' && id && this._respondedAt) ? this._respondedAt[id] : undefined;
+		return typeof at === 'number' ? at : wallClockNow();
+	}
+
 	/**
 	 * Open (or re-open) the live stream for `itemId`, or null when this poll must
 	 * not carry one.
@@ -1472,6 +1502,10 @@ export class ChatSession {
 	private _settleLiveStream(st: LiveStreamState, response: any): any {
 		this._closeLiveStream(st, true);
 		if (!isCsrStatusEnvelope(response)) return response;
+		// Before any return below, and for every terminal status: the bubble that
+		// settles this turn is stamped from it whether it ends as an answer, an error
+		// or a truncation.
+		this._noteRespondedAt(st.id, response);
 		// RESOLVED only, and this is not caution, it is correctness. 'cancelled' is the
 		// envelope the user's own Stop produces, and _isCancelledPollResult downstream
 		// is what settles the turn as stopped: hand it an assembled body instead and a
@@ -2076,6 +2110,10 @@ export class ChatSession {
 		var reply: ChatMessage = isErr
 			? { role: 'assistant', content: getErrorMessage(body), isError: true, _serverItemId: itemId }
 			: { role: 'assistant', content: text, _serverItemId: itemId };
+		if (!isErr) {
+			var rNote = extractRetrievalNote(body, text);
+			if (rNote) reply._retrieval = rNote;
+		}
 		if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
 			// The reader is in another chat. Settle it where it belongs and touch
 			// nothing on screen - state.messages is a different conversation's list.
@@ -2583,7 +2621,9 @@ export class ChatSession {
 				if (isErrorResponseBody(response)) return { content: getErrorMessage(response), isError: true };
 				var answer = (params.aiPlatform === 'openai' ? extractOpenAIText(response) : extractClaudeText(response));
 				answer = (answer || '').trim();
-				return { content: answer || 'No text response received from AI provider.', isError: false };
+				// Retrieval memory: what this turn read, off the body's tool blocks (a
+				// streamed turn's `response` is already the assembled body here).
+				return { content: answer || 'No text response received from AI provider.', isError: false, retrieval: extractRetrievalNote(response, answer) };
 			})
 			.catch(function (err: any) { return { content: getErrorMessage(err), isError: true }; })
 			.then(function (result: any) {
@@ -2602,6 +2642,7 @@ export class ChatSession {
 				}
 				var reply: ChatMessage = { role: 'assistant', content: result.content, isError: result.isError };
 				if (dispatchItemId) reply._serverItemId = dispatchItemId;
+				if (result.retrieval) reply._retrieval = result.retrieval;
 
 				// REPLACE the trailing pending "Thinking..." bubble in the cache with
 				// the answer, regardless of whether this chat is the currently-visible
@@ -3377,7 +3418,7 @@ 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 (msg && msg.role === 'assistant' && msg._ts === undefined) msg._ts = this._replyStampFor(msg);
 		// Overwrite only a placeholder that genuinely belongs to the turn above it.
 		// Two things now sit at this index that must never be replaced by a chat
 		// answer: a background "Indexing:" placeholder (a file's rows are inserted
@@ -3437,6 +3478,10 @@ export class ChatSession {
 			var offReply: ChatMessage = isErrorResponseBody(response)
 				? { role: 'assistant', content: getErrorMessage(response), isError: true }
 				: { role: 'assistant', content: ((platform === 'openai' ? extractOpenAIText(response) : extractClaudeText(response)) || '').trim() || 'No text response received from AI provider.' };
+			if (!offReply.isError) {
+				var offNote = extractRetrievalNote(response, offReply.content);
+				if (offNote) offReply._retrieval = offNote;
+			}
 			this._applyReplyToCache(ownerKey, offReply, serverId);
 			if (serverId) this.cancelledServerIds.delete(serverId);
 			return;
@@ -3452,6 +3497,9 @@ export class ChatSession {
 		} else {
 			var answer = (platform === 'openai' ? extractOpenAIText(response) : extractClaudeText(response));
 			answer = (answer || '').trim() || 'No text response received from AI provider.';
+			// Retrieval memory for this turn, attached to whichever bubble below ends up
+			// holding the answer.
+			var qNote = extractRetrievalNote(response, answer);
 			var lid = this._newLocalId();
 			if (targetIdx >= 0 && this.state.messages[targetIdx] && this.state.messages[targetIdx].isPending) {
 				// Same resume as the immediate-send path: keep what the stream painted
@@ -3465,14 +3513,19 @@ export class ChatSession {
 				var qSettled: any = { role: 'assistant', content: qPainted, _localId: lid };
 				if (prevQ._serverItemId) qSettled._serverItemId = prevQ._serverItemId;
 				if (prevQ._ownerKey) qSettled._ownerKey = prevQ._ownerKey;
+				if (qNote) qSettled._retrieval = qNote;
 				this.state.messages[targetIdx] = qSettled;
 				this.host.notify(); this.enqueueTypewrite(targetIdx, answer, lid, qPainted);
 			} else if (targetIdx >= 0) {
-				this.state.messages.splice(targetIdx, 0, { role: 'assistant', content: '', _localId: lid });
+				var qInsert: ChatMessage = { role: 'assistant', content: '', _localId: lid };
+				if (qNote) qInsert._retrieval = qNote;
+				this.state.messages.splice(targetIdx, 0, qInsert);
 				this.host.notify(); this.enqueueTypewrite(targetIdx, answer, lid);
 			} else {
 				var aiIdx = this.state.messages.length;
-				this.state.messages.push({ role: 'assistant', content: '', _localId: lid });
+				var qAppend: ChatMessage = { role: 'assistant', content: '', _localId: lid };
+				if (qNote) qAppend._retrieval = qNote;
+				this.state.messages.push(qAppend);
 				this.host.notify(); this.enqueueTypewrite(aiIdx, answer, lid);
 			}
 		}
@@ -4069,9 +4122,11 @@ export class ChatSession {
 		// 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`.
+		// timestamp; a history reload later replaces it with the server's own.
+		// _replyStampFor prefers the time skapi received the response when the settle
+		// reported one (a streamed turn), over this browser's clock.
 		var target = this.state.messages[idx];
-		if (target && target._ts === undefined) target._ts = wallClockNow();
+		if (target && target._ts === undefined) target._ts = this._replyStampFor(target);
 		// SELF-HEALING, because this is now reached from the live paint path too. The
 		// queue is a class field, so it is only initialised by the constructor; any
 		// caller holding a ChatSession built another way (the engine tests drive
@@ -4130,6 +4185,9 @@ export class ChatSession {
 		var settled: any = { role: 'assistant', content: painted, isPending: false, _localId: lid };
 		if (prevSettled._serverItemId) settled._serverItemId = prevSettled._serverItemId;
 		if (prevSettled._ownerKey) settled._ownerKey = prevSettled._ownerKey;
+		// The retrieval note rides with the cached reply; the typewriter only
+		// writes `content`, so it survives the reveal.
+		if (latest._retrieval) settled._retrieval = latest._retrieval;
 		this.state.messages[pendingIdx] = settled;
 		this._removeStrayPendingAssistants();
 		this.host.notify();
@@ -4423,6 +4481,9 @@ export class ChatSession {
 		// before and after a reload. Only an INDEXING pass has a protocol token to
 		// hide.
 		var reportedComplete = !isErr && !!answer && answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1;
+		// Retrieval memory for a CHAT turn that settled through a re-attached poll.
+		// Read once here; the background branches below never use it.
+		var hNote = isErr ? null : extractRetrievalNote(response, answer);
 		var stripMarker = function (t: string): string {
 			return reportedComplete ? t.split(INDEXING_COMPLETE_MARKER).join('').trim() : t;
 		};
@@ -4464,7 +4525,9 @@ export class ChatSession {
 			// the reader watched arrive.
 			var hPainted = this._paintedTextAt(idx);
 			var lid = this._newLocalId();
-			this.state.messages[idx] = { role: 'assistant', content: hPainted, _localId: lid, _serverItemId: itemId };
+			var hReply: ChatMessage = { role: 'assistant', content: hPainted, _localId: lid, _serverItemId: itemId };
+			if (hNote) hReply._retrieval = hNote;
+			this.state.messages[idx] = hReply;
 			this.host.notify(); this.enqueueTypewrite(idx, text, lid, hPainted);
 			this.updateHistoryCache(); return;
 		}
@@ -4497,6 +4560,7 @@ export class ChatSession {
 		}
 		var lid2 = this._newLocalId();
 		var reply: ChatMessage = { role: 'assistant', content: '', _localId: lid2, _serverItemId: itemId };
+		if (hNote) reply._retrieval = hNote;
 		this.state.messages.splice(userIdx + 1, 0, reply);
 		this.host.notify(); this.enqueueTypewrite(userIdx + 1, text2, lid2);
 		this.updateHistoryCache();

package/styles/chat.css

@@ -149,6 +149,37 @@
     font-style: italic;
     clear: both;
 }
+/* ---- citations + the no-source mark -------------------------------------*/
+/* Under an answer that read something: one chip per cited file (and page, in
+   the label only). The chips are the ordinary stored-file link chips
+   (.bq-link-button, emitted by renderInlineLinkHtml), so they inherit the
+   expired / refreshing / unavailable states and the hover rule; this only lays
+   them out as a row under a hairline. Absent entirely when there is nothing to
+   cite, so a plain bubble is laid out exactly as before. */
+.bq-citations {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: baseline;
+    gap: 0.25rem 0.6rem;
+    margin-top: 0.45rem;
+    padding-top: 0.35rem;
+    border-top: 1px solid var(--bq-line);
+    font-size: 0.72rem;
+    line-height: 1.35;
+    white-space: normal;
+    clear: both;
+}
+.bq-citations .bq-link-button { max-width: 16rem; }
+/* The answer used no data tool: a small muted line, never a colour that reads
+   as an error (the answer may still be right; what it was not is READ). */
+.bq-no-source-note {
+    display: block;
+    margin-top: 0.35rem;
+    font-size: 0.68rem;
+    font-style: italic;
+    color: var(--bq-muted);
+    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 {