bunnyquery 1.11.1 → 1.12.1

package/dist/engine.cjs

@@ -627,6 +627,11 @@ function getErrorMessage(input) {
   }
   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;
@@ -3298,6 +3303,7 @@ function mapHistoryListToMessages(list, platform, opts) {
       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;
@@ -4326,7 +4332,9 @@ var ChatSession = class {
       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;
@@ -4367,9 +4375,16 @@ var ChatSession = class {
       });
     });
     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;
   }
@@ -5382,6 +5397,7 @@ var ChatSession = class {
       }
       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();
@@ -5391,6 +5407,10 @@ var ChatSession = class {
     }).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);
@@ -5869,8 +5889,9 @@ var ChatSession = class {
       }
     });
     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);
@@ -6049,6 +6070,10 @@ var ChatSession = class {
   }
   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);
@@ -6248,6 +6273,191 @@ var ChatSession = class {
       }
     });
   }
+  /**
+   * 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.
@@ -6314,6 +6524,7 @@ var ChatSession = class {
       }
     }
     this._adoptWorkerIndexingPasses(0);
+    this._sweepCancelledIndexing();
     var ids = group.cancellableIds || [];
     if (!ids.length) {
       this.host.notify();
@@ -6596,9 +6807,10 @@ var ChatSession = class {
     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);
       });
@@ -8227,8 +8439,19 @@ function buildChatDisplayList(messages, opts) {
     } 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++) {
@@ -8693,6 +8916,7 @@ exports.isOfficeFile = isOfficeFile;
 exports.isPagedReadFile = isPagedReadFile;
 exports.isPreviewableImagePath = isPreviewableImagePath;
 exports.isProviderApiKeyError = isProviderApiKeyError;
+exports.isRetriedFailure = isRetriedFailure;
 exports.isServerExtractable = isServerExtractable;
 exports.isServiceDbAttachmentHref = isServiceDbAttachmentHref;
 exports.isWindowedReadFile = isWindowedReadFile;