bunnyquery 1.11.1 → 1.13.0

package/dist/engine.mjs

@@ -357,10 +357,15 @@ function buildChatSystemPrompt(params) {
   const { projectId, serviceName, serviceDescription, greeting, canUpload, client } = params;
   const g = params.indexAccessGroup;
   const indexGroupLiteral = typeof g === "number" ? String(g) : g === "public" || g === "private" || g === "authorized" || g === "admin" ? `"${g}"` : '"authorized"';
+  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.
@@ -625,6 +630,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;
@@ -3248,8 +3258,9 @@ function mapHistoryListToMessages(list, platform, opts) {
     var createdTs = Number(item && item.created);
     var updatedTs = Number(item && item.updated);
     var executedTs = Number(item && item.executed);
+    var respondedTs = Number(item && item.responded);
     var userTs = isFinite(createdTs) && createdTs > 0 ? createdTs : isFinite(updatedTs) && updatedTs > 0 ? updatedTs : void 0;
-    var replyTs = isFinite(updatedTs) && updatedTs > 0 ? updatedTs : isFinite(createdTs) && createdTs > 0 ? createdTs : void 0;
+    var replyTs = isFinite(respondedTs) && respondedTs > 0 ? respondedTs : isFinite(updatedTs) && updatedTs > 0 ? updatedTs : isFinite(createdTs) && createdTs > 0 ? createdTs : void 0;
     if (userText) {
       var displayContent;
       var indexFile = void 0;
@@ -3296,6 +3307,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;
@@ -3875,6 +3887,13 @@ var ChatSession = class {
     // the request budget MAX_CONCURRENT_BG_POLLS exists to protect.
     /** Live streams by server item id. One per in-flight streamed turn. */
     this.liveStreams = {};
+    /** 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. */
+    this._respondedAt = {};
     // ─── compact-stub hydration ─────────────────────────────────────────────
     // Split-fetch bg pages arrive as label stubs (no bodies). When the user
     // expands a row, the real reply text is fetched per item (csr-poll point
@@ -4324,7 +4343,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;
@@ -4365,9 +4386,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;
   }
@@ -4391,6 +4419,23 @@ var ChatSession = class {
     });
     return n;
   }
+  _noteRespondedAt(itemId, response) {
+    if (!itemId || !isCsrStatusEnvelope(response)) return;
+    var at = Number(response.responded);
+    if (!isFinite(at) || at <= 0) return;
+    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. */
+  _replyStampFor(msg) {
+    var id = msg ? msg._serverItemId : void 0;
+    var at = typeof id === "string" && id && this._respondedAt ? this._respondedAt[id] : void 0;
+    return typeof at === "number" ? at : wallClockNow();
+  }
   /**
    * Open (or re-open) the live stream for `itemId`, or null when this poll must
    * not carry one.
@@ -4580,6 +4625,7 @@ var ChatSession = class {
   _settleLiveStream(st, response) {
     this._closeLiveStream(st, true);
     if (!isCsrStatusEnvelope(response)) return response;
+    this._noteRespondedAt(st.id, response);
     if (response.status !== "resolved") return response;
     if (!this._mayFinalize(st)) this._rec().incomplete[st.id] = true;
     if (st.finalBody == null) return response;
@@ -5380,6 +5426,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();
@@ -5389,6 +5436,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);
@@ -5867,8 +5918,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);
@@ -6015,7 +6067,7 @@ var ChatSession = class {
     return thinkingIdx !== -1 ? thinkingIdx : userIdx >= 0 ? userIdx + 1 : -1;
   }
   insertAtTarget(msg, targetIdx) {
-    if (msg && msg.role === "assistant" && msg._ts === void 0) msg._ts = wallClockNow();
+    if (msg && msg.role === "assistant" && msg._ts === void 0) msg._ts = this._replyStampFor(msg);
     var tgt = targetIdx >= 0 ? this.state.messages[targetIdx] : void 0;
     var replaceable = !!tgt && !!tgt.isPending && !tgt.isBackgroundTask && this._isOwnPlaceholderOf(targetIdx, this._owningUserIndex(targetIdx));
     if (replaceable) this.state.messages[targetIdx] = msg;
@@ -6047,6 +6099,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);
@@ -6246,6 +6302,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.
@@ -6312,6 +6553,7 @@ var ChatSession = class {
       }
     }
     this._adoptWorkerIndexingPasses(0);
+    this._sweepCancelledIndexing();
     var ids = group.cancellableIds || [];
     if (!ids.length) {
       this.host.notify();
@@ -6448,7 +6690,7 @@ var ChatSession = class {
   enqueueTypewrite(idx, fullText, localId, paintedText) {
     var self = this;
     var target = this.state.messages[idx];
-    if (target && target._ts === void 0) target._ts = wallClockNow();
+    if (target && target._ts === void 0) target._ts = this._replyStampFor(target);
     if (!this.typewriterQueue) this.typewriterQueue = Promise.resolve();
     this.typewriterQueue = this.typewriterQueue.then(function() {
       return self.typewriteIntoIndex(idx, fullText, localId, paintedText);
@@ -6594,9 +6836,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);
       });
@@ -8225,8 +8468,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++) {
@@ -8539,6 +8793,6 @@ function clearProjectSettings(service) {
   else cache.clear();
 }
 
-export { BG_INDEXING_QUEUE_SUFFIX, BOM, BOM_EXTS, CHAT_GREETING_MAX_LENGTH, CLAUDE_INPUT_CAP_RATIO, CLAUDE_PER_REQUEST_INPUT_CAP, CONTEXT_WINDOW_BY_MODEL, CONTEXT_WINDOW_DEFAULT, ChatSession, DEFAULT_CLAUDE_MODEL, DEFAULT_CONTEXT_WINDOW, DEFAULT_OPENAI_MODEL, DEFAULT_UPLOAD_ACCESS_GROUP, EMPTY_INDEXING_REPLY, EXPIRED_ATTACHMENT_URL_HOST, EXPIRED_ATTACHMENT_URL_ORIGIN, EXPIRED_LINK_REFRESH_EXPIRES_SECONDS, EXT_CONTENT_TYPES, HISTORY_BUDGET_RATIO, HISTORY_FILL_SLACK_PX, HISTORY_TOKEN_BUDGET, HTML_EXTS, HTML_HEAD_WINDOW, IMAGE_PREVIEWS_PER_MESSAGE, INDEXING_COMPLETE_MARKER, INDEXING_MAX_OUTPUT_TOKENS, INLINE_LINK_GLYPH, INLINE_LINK_UNAVAILABLE_GLYPH, INLINE_LINK_UNAVAILABLE_SUFFIX, INPUT_CAP_RATIO, LINK_LABEL_MAX_DISPLAY_CHARS, LINK_REFRESH_WINDOW_MS, MAX_CONCURRENT_BG_POLLS, MAX_HISTORY_FILL_PAGES, MAX_HISTORY_MESSAGES, MAX_OUTPUT_BY_MODEL, MAX_OUTPUT_TOKENS, MAX_PARSED_CONTENT_CHARS, MCP_NAME, MINT_CACHE_GENERATION, MIN_INPUT_TOKEN_BUDGET, MIN_PER_REQUEST_INPUT_CAP, OUTPUT_TOKEN_RESERVE, POLL_INTERVAL, PRESIGN_SAFETY_MARGIN_MS, PREVIEWABLE_IMAGE_CONTENT_TYPES, PREVIEW_BROWSER_CACHE_SECONDS, PREVIEW_LAYOUT_BOX_SELECTOR, PREVIEW_URL_EXPIRES_SECONDS, PROJECT_SETTINGS_ACCESS_GROUP, PROJECT_SETTINGS_TABLE, PROJECT_SETTINGS_UNIQUE_ID, RENDER_FROM_TOKEN, RTF_EXTS, RUN_RECORD_WORKING_STALE_MS, STREAM_POLL_INTERVAL, TOOL_AND_RESPONSE_BUFFER, UPLOAD_ACCESS_GROUPS, UPLOAD_ACCESS_HINTS, UPLOAD_ACCESS_LABELS, UPLOAD_ACCESS_OPTIONS, XML_EXTS, __resetSplitHistoryState, accessSettingFrom, adoptLocalAnswerIntoPage, applyEncodingDeclaration, asksUploadAccessFrom, bgIndexingQueueName, buildAiAgentValue, buildBoundedChatMessages, buildChatDisplayList, buildChatGreeting, buildChatSystemPrompt, buildDisplayExpiredAttachmentHref, buildHistoryItemFullId, buildIndexingContinueMessage, buildIndexingRenderContinueTemplate, buildIndexingRenderMessage, buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingWindowMessage, cachedProjectSettings, callClaudeWithMcp, callClaudeWithPublicMcp, callOpenAIWithPublicMcp, canonicalizePathForm, chatCacheKey, chatEngineConfig, chatGreetingFrom, chatStreamWiring, classifyInlineLink, clearAttachmentParsers, clearImagePreviewCache, clearProjectSettings, composeUserMessage, configureChatEngine, configureProjectSettings, contentTypeForExt, createHistoryFiller, createInlineLinkRegex, createScrollAnchor, createSseParser, csrEnvelopeError, encodePathSegments, encodingClassForExt, ensureHtmlCharset, ensureXmlEncoding, escapeInlineHtml, escapeRtfNonAscii, estimateMessageTokens, estimateTextTokens, extOf, extractClaudeText, extractLastUserTextFromRequest, extractOpenAIText, extractRemotePathFromAttachmentHref, fetchLiveIndexingKeys, fillHistoryViewport, filterListByClearHorizon, findAttachmentParser, formatChatTimestamp, formatDuration, getAttachmentParsers, getChatHistory, getContextWindow, getErrorMessage, getExpiredAttachmentVisiblePath, getInputTokenBudget, getMaxOutputTokens, getModelContextWindow, getProjectContextWindow, getSplitChatHistory, getVisionProfile, groupAttachmentFailures, hasBom, hydrateImagePreviews, indexDoneUniqueId, indexScopeKey, indexingAccessGroup, isAuthExpiredError, isBgIndexingQueue, isCsrStatusEnvelope, isErrorResponseBody, isHttpUrlLike, isImageVisionFile, isIndexingRequestText, isLinkUnavailable, isNonRetryableRequestError, isOfficeFile, isPagedReadFile, isPreviewableImagePath, isProviderApiKeyError, isServerExtractable, isServiceDbAttachmentHref, isWindowedReadFile, linkUnavailableKeyForHref, linkUnavailableKeyForPath, linkUnavailableKeysForPath, listClaudeModels, listOpenAIModels, liveSafePrefix, loadProjectSettings, looksLikeRtf, makeExtractPlaceholder, mapHistoryListToMessages, markImagePreviewStale, mayKeepStreamedAnswer, mintCacheBustStamp, needsBomForExt, normalizeAttachmentPathCandidate, normalizeChatGreeting, normalizeExt, normalizeProjectAccessSetting, normalizeTextContent, normalizeTrailingInlineToken, normalizeUploadAccessGroup, notifyAgentSaveAttachment, parseAiAgentValue, parseAttachmentContent, parseIndexingLabel, parseIndexingRequestText, patchProjectSettings, peekImagePreviewUrl, prepareDownloadText, presignExpiryEpochMs, previewImageContentType, previewLayoutBox, previewMintCacheToken, previewableExtOf, primeProjectSettings, projectAccessSetting, projectAsksUploadAccess, projectChatGreeting, projectSettingsSettled, projectUploadAccessGroup, readExpiredAttachmentHref, readyProjectSettings, registerAttachmentParser, registerModelContextWindows, renderInlineLinkHtml, repairUrlEntities, repairUrlWhitespace, resolveImagePreviewUrl, runIndexUniqueId, safeDecodeURIComponent, sanitizeAttachmentLinksForHistory, setProjectContextWindow, setProjectSettings, shouldRescueInFlightMessage, skapiSupportsStreaming, streamRecoveryEnabled, streamRecoveryLabels, streamRecoveryPhase, stripFileBlocksFromHistory, transformContentWithImages, transformContentWithOpenAIImages, truncateLabelForDisplay, typewriterResumeIndex, uploadAccessGroupFrom, upsertIndexRunRecordSafe, wallClockNow };
+export { BG_INDEXING_QUEUE_SUFFIX, BOM, BOM_EXTS, CHAT_GREETING_MAX_LENGTH, CLAUDE_INPUT_CAP_RATIO, CLAUDE_PER_REQUEST_INPUT_CAP, CONTEXT_WINDOW_BY_MODEL, CONTEXT_WINDOW_DEFAULT, ChatSession, DEFAULT_CLAUDE_MODEL, DEFAULT_CONTEXT_WINDOW, DEFAULT_OPENAI_MODEL, DEFAULT_UPLOAD_ACCESS_GROUP, EMPTY_INDEXING_REPLY, EXPIRED_ATTACHMENT_URL_HOST, EXPIRED_ATTACHMENT_URL_ORIGIN, EXPIRED_LINK_REFRESH_EXPIRES_SECONDS, EXT_CONTENT_TYPES, HISTORY_BUDGET_RATIO, HISTORY_FILL_SLACK_PX, HISTORY_TOKEN_BUDGET, HTML_EXTS, HTML_HEAD_WINDOW, IMAGE_PREVIEWS_PER_MESSAGE, INDEXING_COMPLETE_MARKER, INDEXING_MAX_OUTPUT_TOKENS, INLINE_LINK_GLYPH, INLINE_LINK_UNAVAILABLE_GLYPH, INLINE_LINK_UNAVAILABLE_SUFFIX, INPUT_CAP_RATIO, LINK_LABEL_MAX_DISPLAY_CHARS, LINK_REFRESH_WINDOW_MS, MAX_CONCURRENT_BG_POLLS, MAX_HISTORY_FILL_PAGES, MAX_HISTORY_MESSAGES, MAX_OUTPUT_BY_MODEL, MAX_OUTPUT_TOKENS, MAX_PARSED_CONTENT_CHARS, MCP_NAME, MINT_CACHE_GENERATION, MIN_INPUT_TOKEN_BUDGET, MIN_PER_REQUEST_INPUT_CAP, OUTPUT_TOKEN_RESERVE, POLL_INTERVAL, PRESIGN_SAFETY_MARGIN_MS, PREVIEWABLE_IMAGE_CONTENT_TYPES, PREVIEW_BROWSER_CACHE_SECONDS, PREVIEW_LAYOUT_BOX_SELECTOR, PREVIEW_URL_EXPIRES_SECONDS, PROJECT_SETTINGS_ACCESS_GROUP, PROJECT_SETTINGS_TABLE, PROJECT_SETTINGS_UNIQUE_ID, RENDER_FROM_TOKEN, RTF_EXTS, RUN_RECORD_WORKING_STALE_MS, STREAM_POLL_INTERVAL, TOOL_AND_RESPONSE_BUFFER, UPLOAD_ACCESS_GROUPS, UPLOAD_ACCESS_HINTS, UPLOAD_ACCESS_LABELS, UPLOAD_ACCESS_OPTIONS, XML_EXTS, __resetSplitHistoryState, accessSettingFrom, adoptLocalAnswerIntoPage, applyEncodingDeclaration, asksUploadAccessFrom, bgIndexingQueueName, buildAiAgentValue, buildBoundedChatMessages, buildChatDisplayList, buildChatGreeting, buildChatSystemPrompt, buildDisplayExpiredAttachmentHref, buildHistoryItemFullId, buildIndexingContinueMessage, buildIndexingRenderContinueTemplate, buildIndexingRenderMessage, buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingWindowMessage, cachedProjectSettings, callClaudeWithMcp, callClaudeWithPublicMcp, callOpenAIWithPublicMcp, canonicalizePathForm, chatCacheKey, chatEngineConfig, chatGreetingFrom, chatStreamWiring, classifyInlineLink, clearAttachmentParsers, clearImagePreviewCache, clearProjectSettings, composeUserMessage, configureChatEngine, configureProjectSettings, contentTypeForExt, createHistoryFiller, createInlineLinkRegex, createScrollAnchor, createSseParser, csrEnvelopeError, encodePathSegments, encodingClassForExt, ensureHtmlCharset, ensureXmlEncoding, escapeInlineHtml, escapeRtfNonAscii, estimateMessageTokens, estimateTextTokens, extOf, extractClaudeText, extractLastUserTextFromRequest, extractOpenAIText, extractRemotePathFromAttachmentHref, fetchLiveIndexingKeys, fillHistoryViewport, filterListByClearHorizon, findAttachmentParser, formatChatTimestamp, formatDuration, getAttachmentParsers, getChatHistory, getContextWindow, getErrorMessage, getExpiredAttachmentVisiblePath, getInputTokenBudget, getMaxOutputTokens, getModelContextWindow, getProjectContextWindow, getSplitChatHistory, getVisionProfile, groupAttachmentFailures, hasBom, hydrateImagePreviews, indexDoneUniqueId, indexScopeKey, indexingAccessGroup, isAuthExpiredError, isBgIndexingQueue, isCsrStatusEnvelope, isErrorResponseBody, isHttpUrlLike, isImageVisionFile, isIndexingRequestText, isLinkUnavailable, isNonRetryableRequestError, isOfficeFile, isPagedReadFile, isPreviewableImagePath, isProviderApiKeyError, isRetriedFailure, isServerExtractable, isServiceDbAttachmentHref, isWindowedReadFile, linkUnavailableKeyForHref, linkUnavailableKeyForPath, linkUnavailableKeysForPath, listClaudeModels, listOpenAIModels, liveSafePrefix, loadProjectSettings, looksLikeRtf, makeExtractPlaceholder, mapHistoryListToMessages, markImagePreviewStale, mayKeepStreamedAnswer, mintCacheBustStamp, needsBomForExt, normalizeAttachmentPathCandidate, normalizeChatGreeting, normalizeExt, normalizeProjectAccessSetting, normalizeTextContent, normalizeTrailingInlineToken, normalizeUploadAccessGroup, notifyAgentSaveAttachment, parseAiAgentValue, parseAttachmentContent, parseIndexingLabel, parseIndexingRequestText, patchProjectSettings, peekImagePreviewUrl, prepareDownloadText, presignExpiryEpochMs, previewImageContentType, previewLayoutBox, previewMintCacheToken, previewableExtOf, primeProjectSettings, projectAccessSetting, projectAsksUploadAccess, projectChatGreeting, projectSettingsSettled, projectUploadAccessGroup, readExpiredAttachmentHref, readyProjectSettings, registerAttachmentParser, registerModelContextWindows, renderInlineLinkHtml, repairUrlEntities, repairUrlWhitespace, resolveImagePreviewUrl, runIndexUniqueId, safeDecodeURIComponent, sanitizeAttachmentLinksForHistory, setProjectContextWindow, setProjectSettings, shouldRescueInFlightMessage, skapiSupportsStreaming, streamRecoveryEnabled, streamRecoveryLabels, streamRecoveryPhase, stripFileBlocksFromHistory, transformContentWithImages, transformContentWithOpenAIImages, truncateLabelForDisplay, typewriterResumeIndex, uploadAccessGroupFrom, upsertIndexRunRecordSafe, wallClockNow };
 //# sourceMappingURL=engine.mjs.map
 //# sourceMappingURL=engine.mjs.map