bunnyquery 1.11.1 → 1.12.1

package/README.md

@@ -34,6 +34,11 @@ you can build your own chat UI on top of it. See
   across as many passes as it takes. A file's passes collapse into a single
   status row in the chat that can be expanded, and stopped: "Stop" cancels every
   queued and running pass at once and ends the continuation chain.
+- **Stop waiting**: a reply that is taking too long can be given up on. The
+  "Thinking" bubble carries a small x that cancels the running request on the
+  server, marks the question as cancelled, and lets the next message go out
+  at once instead of queueing behind it. A message still waiting in the queue
+  has the same control on its own bubble.
 - **Attachment parser plugins**: register a client-side parser so the widget
   extracts text in the browser from formats the model can't otherwise read, and
   indexes it directly. See [Attachment parser plugins](#attachment-parser-plugins).

package/bunnyquery.css

@@ -1175,6 +1175,28 @@
 .bq-message.is-assistant:not(.is-error):not(.is-cancelled):not(.bq-index-pass) .bq-bubble:has(> .bq-loader) > .bq-loader {
     vertical-align: middle;
 }
+/* The dot-trail cycles '.', '..', '...', so left to itself it is a box that
+   changes width three times every 1.2s: the bubble pulsed with it, and the
+   stop-waiting control that follows the dots moved each time, which made it hard
+   to hit. Inside a bubble the loader therefore RESERVES the width of its widest
+   frame: a hidden '...' sets the box and the animated dots are laid over it from
+   the left. Sized by the text itself rather than by a length, so it is right in
+   any font and at any letter-spacing. Scoped to bubbles on purpose: a loader that
+   trails a label ("Saving...") has to keep hugging its text. */
+.bq-bubble > .bq-loader {
+    position: relative;
+    display: inline-block;
+    white-space: nowrap;
+}
+.bq-bubble > .bq-loader::before {
+    content: '...';
+    visibility: hidden;
+}
+.bq-bubble > .bq-loader::after {
+    position: absolute;
+    left: 0;
+    top: 0;
+}
 
 .bq-message.is-error .bq-bubble {
     background: var(--bq-danger-bg);
@@ -1187,6 +1209,14 @@
     color: var(--bq-danger);
     opacity: 0.65;
 }
+/* A failed pass the worker has already sent again: real, but not the file's
+   outcome (the replacement pass is), so it is told in the muted voice of a
+   note rather than the red of a dead end. */
+.bq-message.is-error.is-retried .bq-bubble {
+    background: var(--bq-paper);
+    border-color: var(--bq-line);
+    color: var(--bq-muted);
+}
 .bq-message.is-pending-older .bq-bubble {
     background: var(--bq-warning-bg);
     border-color: var(--bq-warning-border);
@@ -1245,6 +1275,35 @@
 }
 .bq-cancel-queue-btn:hover:not(.is-disabled) { background: var(--bq-warning-bg); color: var(--bq-warning); }
 .bq-cancel-queue-btn.is-disabled { opacity: 0.3; cursor: not-allowed; pointer-events: none; }
+/* Stop waiting for a reply: sits INLINE after the dot-trail in a chat turn's own
+   "Thinking" bubble, where the bunny is inline too (:has(> .bq-loader) above).
+   Same face as the queued-message × but placed differently: that one floats to
+   its bubble's corner, this one simply follows the dots. Muted at rest so the
+   dots stay the thing the eye lands on; hover changes opacity only, never its
+   colour. Shared by both chatboxes. */
+.bq-cancel-wait-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    vertical-align: middle;
+    margin-left: 0.55rem;
+    width: 1.1rem;
+    height: 1.1rem;
+    min-height: 0;
+    padding: 0;
+    border: 1px solid var(--bq-line);
+    background: transparent;
+    color: var(--bq-muted);
+    font-size: 0.85rem;
+    line-height: 1;
+    cursor: pointer;
+    box-shadow: none;
+    border-radius: 0;
+    flex-shrink: 0;
+    opacity: 0.7;
+}
+.bq-cancel-wait-btn:hover:not(.is-disabled) { opacity: 1; }
+.bq-cancel-wait-btn.is-disabled { opacity: 0.3; cursor: not-allowed; pointer-events: none; }
 
 /* ---- unfinalized streamed answer (ask for it) ----------------------------
    A turn whose answer was streamed and never finalized keeps its bytes in the

package/bunnyquery.js

@@ -619,6 +619,11 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     return "Something went wrong.";
   }
+  function isRetriedFailure(input) {
+    var envErr = csrEnvelopeError(input);
+    if (envErr !== void 0) input = envErr;
+    return !!input && typeof input === "object" && input.retried === true;
+  }
   function isErrorResponseBody(response) {
     var envErr = csrEnvelopeError(response);
     if (envErr !== void 0) response = envErr;
@@ -3154,6 +3159,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         mapped.push(ph);
       } else if (isQueued) ; else if (isErrorResponse) {
         var em = { role: "assistant", content: getErrorMessage(response), isError: true };
+        if (isRetriedFailure(response)) em.isRetried = true;
         if (item._fromBgChain) em._fromBgChain = true;
         if (item._isBgTask) em.isBackgroundTask = true;
         if (serverItemId !== void 0) em._serverItemId = serverItemId;
@@ -4182,7 +4188,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         timers = [];
       };
       var stopBase = base && typeof base.stop === "function" ? base.stop.bind(base) : null;
+      var resolveRaced = null;
       var raced = new Promise(function(resolve, reject) {
+        resolveRaced = resolve;
         base.then(function(res) {
           if (settled) return;
           settled = true;
@@ -4223,9 +4231,16 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         });
       });
       raced.stop = function() {
+        if (settled) return;
         settled = true;
         clearProbes();
-        if (stopBase) stopBase();
+        if (stopBase) {
+          try {
+            stopBase();
+          } catch (e) {
+          }
+        }
+        if (resolveRaced) resolveRaced({ id: itemId, status: "stopped" });
       };
       return raced;
     }
@@ -5238,6 +5253,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
         return response;
       }).then(function(response) {
+        if (isPollStopped(response) || self._isCancelledPollResult(response)) return { content: "", isError: false, cancelled: true };
         if (isErrorResponseBody(response)) return { content: getErrorMessage(response), isError: true };
         var answer = params.aiPlatform === "openai" ? extractOpenAIText(response) : extractClaudeText(response);
         answer = (answer || "").trim();
@@ -5247,6 +5263,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }).then(function(result) {
         delete self.pendingAgentRequests[params.key];
         if (dispatchItemId) self.historyItemPolls.delete(dispatchItemId);
+        if (result.cancelled) {
+          if (dispatchItemId) self._settleCancelledTurn(dispatchItemId, params.key);
+          return result;
+        }
         var reply = { role: "assistant", content: result.content, isError: result.isError };
         if (dispatchItemId) reply._serverItemId = dispatchItemId;
         self._applyReplyToCache(params.key, reply, dispatchItemId);
@@ -5725,8 +5745,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       });
       Promise.resolve(run).catch(function() {
-      }).then(function() {
+      }).then(function(result) {
         self.state.sending = false;
+        if (result && result.cancelled) return;
         if (!(self.host.isViewMounted() && self.getHistoryCacheKey() === key)) return;
         return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
           self.host.scrollToBottomIfSticky(true);
@@ -5905,6 +5926,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     onQueuedSendResponse(_composed, response, platform, serverId, ownerKey) {
       if (serverId) this.historyItemPolls.delete(serverId);
+      if (this._isCancelledPollResult(response)) {
+        if (serverId) this._settleCancelledTurn(serverId, ownerKey);
+        return;
+      }
       if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
         var offReply = 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." };
         this._applyReplyToCache(ownerKey, offReply, serverId);
@@ -6104,6 +6129,191 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       });
     }
+    /**
+     * Stop waiting for the reply to the chat turn that is running now, and move on.
+     *
+     * `msg` is the turn's pending ASSISTANT bubble (the dot-trail "Thinking"
+     * placeholder), which is where both views draw the control. A turn's two bubbles
+     * carry the same _serverItemId, so it is also how the request is found.
+     * cancelQueuedMessage is the sibling for a turn still waiting in the queue and
+     * takes the USER bubble; the two differ in what they are handed and in what has
+     * to be unwound afterwards, not in what the server is asked.
+     *
+     * What ends the wait:
+     *   1. csr-cancel marks the running row cancelled. The worker stops relaying and
+     *      never stores an answer for it, so the reply cannot turn up later on this
+     *      device or another, and history replays the turn as cancelled;
+     *   2. the poll on it is stopped, which settles whichever chain was awaiting it
+     *      with a stopped result: dispatchAgentRequest's for an immediate send, the
+     *      queued chain for a promoted turn, the history poll after a reload. Each
+     *      reads a stopped or cancelled result as "no reply" and releases what it
+     *      holds (state.sending, pendingAgentRequests, historyItemPolls), which is
+     *      what lets the next send go out immediately instead of queueing;
+     *   3. the bubbles settle at once, without waiting for that chain: the user
+     *      bubble takes its cancelled form, the placeholder goes, and the next queued
+     *      turn, if there is one, is promoted so its own "Thinking" appears.
+     *
+     * What it does NOT do: the provider call already in flight on the worker runs
+     * to its end (a streamed one stops within about a second). A message sent
+     * behind it on the same queue starts once the worker acks the cancelled row.
+     *
+     * Refused without a server id (the ack has not come back yet; the views disable
+     * the control until it has) and while a cancel is already out. Indexing passes
+     * are not this method's business: their Stop is cancelIndexingGroup, which ends
+     * the file's whole chain.
+     */
+    cancelPendingReply(msg, idx) {
+      var self = this;
+      var id = this.host.getIdentity();
+      var serverId = msg._serverItemId;
+      if (!serverId || msg._cancelling) return;
+      if (msg.role !== "assistant" || !msg.isPending || msg.isBackgroundTask) return;
+      var platform = id.platform;
+      if (platform !== "claude" && platform !== "openai") return;
+      var url = platform === "claude" ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
+      var queueBase = id.userId || id.projectId;
+      var queue = msg._useBgQueue ? bgIndexingQueueName(queueBase) : queueBase;
+      var findPlaceholder = function() {
+        return self.state.messages.findIndex(function(m) {
+          return m._serverItemId === serverId && m.role === "assistant" && !!m.isPending;
+        });
+      };
+      var at = this.state.messages[idx] && this.state.messages[idx]._serverItemId === serverId && this.state.messages[idx].role === "assistant" ? idx : findPlaceholder();
+      if (at !== -1) {
+        this.state.messages[at] = Object.assign({}, this.state.messages[at], { _cancelling: true, _cancelError: void 0 });
+      }
+      this.host.notify();
+      var unmark = function(errMsg) {
+        var ci = findPlaceholder();
+        if (ci === -1) return;
+        self.state.messages[ci] = Object.assign({}, self.state.messages[ci], { _cancelling: false, _cancelError: errMsg });
+        self.host.notify();
+      };
+      Promise.resolve(this.host.cancelRequest({
+        url,
+        method: "POST",
+        id: serverId,
+        queue,
+        service: id.projectId,
+        owner: id.owner
+      })).then(function(result) {
+        if (result && result.removed) {
+          self._stopPoll(serverId);
+          self._settleCancelledTurn(serverId);
+          return;
+        }
+        unmark(void 0);
+      }).catch(function(err) {
+        unmark(err && typeof err.message === "string" && err.message ? err.message : "Could not stop this request.");
+      });
+    }
+    /** The cancelled form of a request bubble, with everything that keeps it in
+     *  place carried over: the file markers that hold an indexing pass in its
+     *  collapsed row, the chat it belongs to, its send time and its render key. */
+    _cancelledCopyOf(m, itemId) {
+      var cancelled = { role: "user", content: m.content, isCancelled: true };
+      if (itemId !== void 0) cancelled._serverItemId = itemId;
+      else if (m._serverItemId !== void 0) cancelled._serverItemId = m._serverItemId;
+      if (m.isBackgroundTask) cancelled.isBackgroundTask = true;
+      if (m._indexFile) cancelled._indexFile = m._indexFile;
+      if (m._useBgQueue) cancelled._useBgQueue = true;
+      if (m._ownerKey !== void 0) cancelled._ownerKey = m._ownerKey;
+      if (m._ts !== void 0) cancelled._ts = m._ts;
+      if (m._localId !== void 0) cancelled._localId = m._localId;
+      return cancelled;
+    }
+    /**
+     * Settle a turn as cancelled wherever it lives, and let the queue move on.
+     *
+     * On the chat on screen: every pending placeholder carrying the id goes (a
+     * history refetch can have re-mapped the running turn into a second one), the
+     * request bubble takes its cancelled form, and the next queued turn is promoted
+     * so the conversation does not sit on an "(In queue)" bubble with nothing
+     * running. For a chat that is NOT on screen (the user moved on while the turn
+     * ran, and it was cancelled from elsewhere) the same edit is made in that chat's
+     * history cache, which is what the next visit renders.
+     *
+     * Idempotent on purpose: a cancel this client made settles the bubbles at once,
+     * and the chain that was awaiting the poll settles again a moment later when the
+     * stop resolves it. The second pass finds nothing to do. Deliberately NOT
+     * _removeStrayPendingAssistants: by then the placeholder on screen is the freshly
+     * promoted turn's, whose user bubble is pending, and the sweep would take it.
+     */
+    _settleCancelledTurn(itemId, ownerKey) {
+      if (!itemId) return;
+      if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
+        this._applyCancelToCache(ownerKey, itemId);
+        return;
+      }
+      var changed = false, wasBg = false;
+      for (var i = this.state.messages.length - 1; i >= 0; i--) {
+        var m = this.state.messages[i];
+        if (!m || m._serverItemId !== itemId) continue;
+        if (m.role === "assistant" && m.isPending) {
+          this.state.messages.splice(i, 1);
+          changed = true;
+          continue;
+        }
+        if (m.role === "user" && !m.isCancelled) {
+          if (m.isBackgroundTask) wasBg = true;
+          this.state.messages[i] = this._cancelledCopyOf(m, itemId);
+          changed = true;
+        }
+      }
+      this.cancelledServerIds.delete(itemId);
+      if (!changed) return;
+      if (wasBg) this.promoteNextBgQueuedToRunning();
+      else this.promoteNextQueuedToRunning();
+      this.updateHistoryCache();
+      this.host.notify();
+    }
+    /**
+     * _settleCancelledTurn for a chat that is not on screen: the same edit, made in
+     * its history cache. Matched by id where the cached bubbles carry one; an
+     * off-chat send caches its pair before the ack (see dispatchComposedMessage), so
+     * the fallback is positional, exactly as _applyReplyToCache's is: the trailing
+     * pending placeholder, and the last request bubble still marked in flight.
+     */
+    _applyCancelToCache(key, itemId) {
+      var existing = key ? this.aiChatHistoryCache[key] : void 0;
+      if (!existing) return;
+      var msgs = existing.messages.slice();
+      var changed = false;
+      var pIdx = -1, uIdx = -1;
+      for (var i = msgs.length - 1; i >= 0; i--) {
+        var m = msgs[i];
+        if (!m || m._serverItemId !== itemId) continue;
+        if (m.role === "assistant" && m.isPending) {
+          msgs.splice(i, 1);
+          changed = true;
+          pIdx = i;
+        } else if (m.role === "user" && !m.isCancelled && uIdx === -1) uIdx = i;
+      }
+      if (pIdx === -1) {
+        for (var p = msgs.length - 1; p >= 0; p--) {
+          var pm = msgs[p];
+          if (!pm || !pm.isPending || pm.role !== "assistant" || pm.isBackgroundTask || pm._serverItemId !== void 0) continue;
+          msgs.splice(p, 1);
+          changed = true;
+          break;
+        }
+      }
+      if (uIdx === -1) {
+        for (var u = msgs.length - 1; u >= 0; u--) {
+          var um = msgs[u];
+          if (!um || um.role !== "user" || um.isBackgroundTask || um._serverItemId !== void 0 || um._stageId) continue;
+          if (!(um.isPendingQueued || um.isPendingInProcess || um.isSendingToServer)) continue;
+          uIdx = u;
+          break;
+        }
+      }
+      if (uIdx !== -1) {
+        msgs[uIdx] = this._cancelledCopyOf(msgs[uIdx], itemId);
+        changed = true;
+      }
+      if (!changed) return;
+      this.aiChatHistoryCache[key] = { messages: msgs, endOfList: existing.endOfList, startKeyHistory: existing.startKeyHistory };
+    }
     /**
      * Stop indexing a file, from its collapsed row — every pass at once, not just
      * the bubble the user happens to see.
@@ -6170,6 +6380,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       }
       this._adoptWorkerIndexingPasses(0);
+      this._sweepCancelledIndexing();
       var ids = group.cancellableIds || [];
       if (!ids.length) {
         this.host.notify();
@@ -6452,9 +6663,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.state.sending = true;
       this.host.scrollToBottomIfSticky(true);
       return Promise.resolve(pending).catch(function() {
-      }).then(function() {
+      }).then(function(result) {
         if (token !== self.state.gateRefreshToken) return;
         self.state.sending = false;
+        if (result && result.cancelled) return;
         return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
           self.host.scrollToBottomIfSticky(true);
         });
@@ -8083,8 +8295,19 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       } else if (stopped) {
         grp.status = "cancelled";
       } else {
-        var last = grp.members[grp.members.length - 1].msg;
-        grp.status = last.isError ? "error" : "done";
+        var retriedIds = {};
+        for (var ri = 0; ri < grp.members.length; ri++) {
+          var rm = grp.members[ri].msg;
+          if (rm.isRetried && rm._serverItemId) retriedIds[rm._serverItemId] = true;
+        }
+        var li = grp.members.length - 1;
+        while (li >= 0 && (grp.members[li].msg.isRetried || grp.members[li].msg._serverItemId && retriedIds[grp.members[li].msg._serverItemId])) li--;
+        if (li < 0) {
+          grp.status = "active";
+        } else {
+          var last = grp.members[li].msg;
+          grp.status = last.isError ? "error" : "done";
+        }
       }
       var sawFirstPass = false;
       for (var pi = 0; pi < grp.members.length; pi++) {
@@ -8374,7 +8597,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   (function() {
     var MCP_PROD = "https://mcp.broadwayinc.computer";
     var MCP_DEV = "https://mcp-dev.broadwayinc.computer";
-    var BQ_VERSION = "1.11.1" ;
+    var BQ_VERSION = "1.12.1" ;
     var ATTACHMENT_URL_EXPIRES_SECONDS = 600;
     var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
     var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
@@ -11657,12 +11880,29 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var cls = ["bq-message"];
       cls.push(msg.role === "user" ? "is-user" : "is-assistant");
       if (msg.isError) cls.push("is-error");
+      if (msg.isRetried) cls.push("is-retried");
       if (msg.isCancelled) cls.push("is-cancelled");
       if (msg.isPendingQueued || msg.isPendingOlder) cls.push("is-pending-older");
       if (msg._dimSending || msg._cancelling) cls.push("is-sending-to-server");
       var bubble;
       if (msg.isPending && !msg._streaming || streamRecoveryPhase(msg) === "active") {
         bubble = h("div", { class: "bq-bubble" }, h("span", { class: "bq-loader" }));
+        if (msg.role === "assistant" && !msg.isBackgroundTask && !streamRecoveryPhase(msg)) {
+          var waitDisabled = !msg._serverItemId || msg._cancelling;
+          var stopWaitBtn = h("button", {
+            class: "bq-cancel-wait-btn" + (waitDisabled ? " is-disabled" : ""),
+            type: "button",
+            title: "Stop waiting for this reply",
+            "aria-label": "Stop waiting for this reply",
+            html: "&times;"
+          });
+          if (!waitDisabled) stopWaitBtn.addEventListener("click", function(e) {
+            e.stopPropagation();
+            session.cancelPendingReply(msg, idx);
+          });
+          bubble.appendChild(stopWaitBtn);
+          if (msg._cancelError) bubble.appendChild(h("span", { class: "bq-cancel-error", text: msg._cancelError }));
+        }
       } else if (streamRecoveryPhase(msg)) {
         var labels = streamRecoveryLabels(streamRecoveryPhase(msg));
         bubble = h("div", { class: "bq-bubble is-stream-recover" + (streamRecoveryPhase(msg) === "failed" ? " is-stream-failed" : "") });