bunnyquery 1.10.6 → 1.10.8

package/package.json

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

package/src/engine/history.ts

@@ -792,6 +792,12 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 		// if one is missing (older records only carried `updated`).
 		var createdTs = Number(item && item.created);
 		var updatedTs = Number(item && item.updated);
+		// When the WORKER began executing this pass, not when it was enqueued. The
+		// SDK normalises it to ms (the worker stamps it in seconds). Absent on a row
+		// that never ran, and on rows written before the SDK projected it -- in both
+		// 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);
 		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);
 
@@ -852,6 +858,13 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			if (item._isBgTask) em.isBackgroundTask = true;
 			if (serverItemId !== undefined) em._serverItemId = serverItemId;
 			if (replyTs !== undefined) em._ts = replyTs;
+			// A pass that FAILED still ran, and how long it ran before failing is worth
+			// as much as a successful pass's duration -- often more, since that is where
+			// a timeout shows itself. `att` is stamped before the upstream call fires,
+			// so a failed row carries it exactly as a resolved one does. (Same stamp as
+			// the success branch below; the stream-pending branch deliberately has none,
+			// having no end time yet.)
+			if (indexFile && isFinite(executedTs) && executedTs > 0) em._tsStart = executedTs;
 			mapped.push(em);
 		} else if (isStreamPending) {
 			// The bubble stands for the turn so the merge has something to key on and
@@ -874,6 +887,17 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			if (isCompact) okm._compact = true;
 			if (serverItemId !== undefined) okm._serverItemId = serverItemId;
 			if (replyTs !== undefined) okm._ts = replyTs;
+			// How long THIS pass took: from the moment the worker began EXECUTING it to
+			// the moment it resolved. Carried on the reply so the bubble can show it
+			// without its request bubble (a continuation's request is hidden from the
+			// expanded row). Only for an indexing pass: `_tsStart`'s presence is what
+			// scopes the duration to indexing responses in both views.
+			//
+			// Deliberately NOT `created`: that is the enqueue time, so a pass that sat
+			// in the queue for an hour before running would have reported the wait as
+			// though it were the read. No fallback to it either, for the same reason --
+			// a missing `executed` means no duration is shown at all.
+			if (indexFile && isFinite(executedTs) && executedTs > 0) okm._tsStart = executedTs;
 			if (reportedComplete) okm._indexComplete = true;
 			mapped.push(okm);
 		}

package/src/engine/host.ts

@@ -225,6 +225,16 @@ export interface ChatMessage {
 	 *  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;
+	/** Epoch ms the worker began EXECUTING this indexing pass (the SDK's `executed`,
+	 *  not the enqueue time `created`), carried on the ASSISTANT bubble so it can
+	 *  show how long the pass actually took
+	 *  without reaching for its request bubble (a continuation's request is
+	 *  deliberately hidden from the expanded row, so it is not always there).
+	 *
+	 *  Stamped ONLY on an indexing pass's reply. Its presence is therefore also
+	 *  what SCOPES the duration to indexing responses: an ordinary chat answer
+	 *  never carries it, so neither view needs a second test. */
+	_tsStart?: number;
 	// History cache key (`projectId#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/time.ts

@@ -32,3 +32,32 @@ export function formatChatTimestamp(ms?: number): string {
 		return '';
 	}
 }
+
+/**
+ * "4s", "2m 4s", "1h 2m 4s" — how long one indexing pass took.
+ *
+ * HOURS ARE THE LARGEST UNIT, deliberately: a pass is a single model turn, so a
+ * span of days is not a long read but bad data (a stale `updated` stamp, a clock
+ * skew, a row rewritten much later). Rolling those into hours makes them read as
+ * the anomaly they are — "49h" — instead of dressing them up as a plausible
+ * "2d 1h".
+ *
+ * A zero unit is dropped rather than padded ("1h 4s", not "1h 0m 4s"); seconds
+ * are always shown so the string is never bare.
+ *
+ * Empty string for anything under a second, negative, or non-finite — a pass
+ * cannot take no time, so those are skew or missing data, and callers gate on
+ * the result being truthy exactly as they do for formatChatTimestamp.
+ */
+export function formatDuration(ms?: number): string {
+	if (typeof ms !== 'number' || !isFinite(ms) || ms < 1000) return '';
+	var total = Math.floor(ms / 1000);
+	var h = Math.floor(total / 3600);
+	var m = Math.floor((total % 3600) / 60);
+	var s = total % 60;
+	var out = [];
+	if (h) out.push(h + 'h');
+	if (m) out.push(m + 'm');
+	out.push(s + 's');
+	return out.join(' ');
+}