bunnyquery 1.12.1 → 1.13.0

package/package.json

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

package/src/engine/history.ts

@@ -798,8 +798,17 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 		// cases the pass simply shows no duration, which is right: the honest answer
 		// to "how long did it take" is nothing, not the queue wait dressed up as it.
 		var executedTs = Number(item && item.executed);
+		// When skapi recorded the destination's response as having finished arriving.
+		// It is the answer's time whenever the row carries it, because `updated` is
+		// not that for a STREAMED turn: finalizing the turn stores its answer a few
+		// seconds later and moves `updated` to that moment. Absent on rows settled
+		// before the worker recorded it, on a turn that failed with no response, and
+		// under an SDK that does not project it. All three fall back to `updated`,
+		// which is exactly what this showed before.
+		var respondedTs = Number(item && item.responded);
 		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);
+		var replyTs = isFinite(respondedTs) && respondedTs > 0 ? respondedTs
+			: (isFinite(updatedTs) && updatedTs > 0 ? updatedTs : (isFinite(createdTs) && createdTs > 0 ? createdTs : undefined));
 
 		if (userText) {
 			var displayContent;

package/src/engine/prompts/chat_system_prompt.ts

@@ -72,10 +72,33 @@ export function buildChatSystemPrompt(params: ChatSystemPromptParams): string {
 		: (g === 'public' || g === 'private' || g === 'authorized' || g === 'admin') ? `"${g}"`
 		: '"authorized"';
 
+	// ---- Grounding ---------------------------------------------------------
+	// The rules around this block were all written against the OPPOSITE mistake: a
+	// model that says "not found" before it has really looked. Read alone they push
+	// one way only (keep searching, never say it is absent), and nothing said the
+	// other half: state only what the data returned. Customers reported answers
+	// that were not in their data at all, which is the one thing this product must
+	// never do, so the other half is spelled out here.
+	//
+	// Three rules, each closing one way an invented answer gets out: a fact with no
+	// source, a "not found" replaced by general knowledge, and an inference worded
+	// as if the data said it. The last line keeps them from swallowing what is NOT
+	// a claim about the project's data (product help, a greeting, authored text).
+	// The upload suggestion follows canUpload for the same reason the About section
+	// does: a visitor who cannot upload must never be told to.
+	const groundingRules =
+`ANSWER ONLY FROM THE DATA. Every fact you state about this project's data - a name, a number, a date, a status, what a document says, whether something exists - must come from one of four places: a tool result returned in THIS conversation, a file or image attached to it (including one you read through its attachment link), the project description at the end of this prompt, or what the user told you themselves in this chat. Your general knowledge, the open internet and a plausible guess are NOT sources. Never use them to answer a question about the user's data, to fill a gap in it, or to complete a record that came back partial. A value that is not in what you retrieved is unknown: say it is not in the data instead of supplying a likely one.
+WHEN THE DATA DOES NOT HAVE IT, SAY SO. Once you have searched the way these rules require and nothing answers the question, tell the user plainly, in their language, that this project's data does not contain it, and say what you searched (the tables, files or terms) so they can tell missing data from a missed search. Do not answer from memory instead, and do not turn a missing answer into a general explanation of the topic. Offer what would let you answer it: ${canUpload === false
+			? `another name or file to look under, or asking the project's owner to add it`
+			: `the document to upload, or another name or file to look under`}.
+KEEP WHAT THE DATA SAYS APART FROM WHAT YOU WORKED OUT. A total you computed, a comparison, a trend, an interpretation or a recommendation is yours, not the data's: label it as such ("calculated from...", "this suggests...") and name the rows or files it was made from. Never present an estimate, an assumption or an inference as something the data states.
+These three rules govern every claim about the project's data. They do not limit the About BunnyQuery section (answer product questions from it), a greeting, or text the user explicitly asks you to write.`;
+
 	let systemPrompt = `
 You are a dedicated assistant for the project ID: "${projectId}".
 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. The ONE exception is BunnyQuery itself - what this app is, what it can do, and how to use it - which is always in scope: answer it from the "About BunnyQuery" section at the end of this prompt.
 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.
+${groundingRules}
 NUMBERS FROM A SPREADSHEET: use queryGrid, never mental arithmetic over records. A total, a count, an average, a "how many mention X", a "which one is biggest" - all of those are computed server-side over EVERY row of the file and come back with the sheet, the row count and the row numbers they were made from. Records are a SAMPLE, and a sample added up is a confident wrong number. Quote the row count and the sheet alongside the figure so the reader can check it.
 CALL queryGrid describe FIRST, before any figure. Workbooks routinely state the same money more than once: a detail sheet, then per-song, per-album and per-artist sheets that each re-total it, plus a summary sheet whose bottom row is the file total. Those look like four different answers and are one. describe names which sheets restate which, and which rows are totals. Pick ONE sheet, say which you picked, and never add figures across a sheet and its summary. If the reply carries a warning about restatement, repeat it to the user.
 A FILE TOTAL IS NOT A ROW'S TOTAL. The biggest number on a summary sheet is the whole file, not the thing that was asked about. Before quoting any figure, check it is scoped to what the question named: filter by the column that identifies it and report how many rows matched.

package/src/engine/session.ts

@@ -1220,6 +1220,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 +1501,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
@@ -3377,7 +3410,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
@@ -4069,9 +4102,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