bunnyquery 1.8.0 → 1.8.2

package/bunnyquery.js

@@ -433,6 +433,19 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   }
 
   // src/engine/errors.ts
+  var STATUS_MESSAGE = {
+    "408": "The AI provider timed out before it started.",
+    "409": "The AI provider rejected the request as conflicting.",
+    "413": "The request was too large for the AI provider.",
+    "429": "The AI provider is rate limiting requests right now.",
+    "500": "The AI provider hit an internal error.",
+    "502": "The AI provider is temporarily unreachable.",
+    "503": "The AI provider is temporarily unavailable.",
+    "504": "The AI provider timed out."
+  };
+  function isTransientStatus(status) {
+    return status === 408 || status === 425 || status === 429 || status >= 500;
+  }
   function getErrorMessage(input) {
     if (!input) return "Something went wrong.";
     if (typeof input === "string") return input;
@@ -440,6 +453,11 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     if (input.body && input.body.error && input.body.error.message) return input.body.error.message;
     if (input.body && typeof input.body.message === "string") return input.body.message;
     if (input.message) return input.message;
+    var status = typeof input.status_code === "number" ? input.status_code : typeof input.status === "number" ? input.status : 0;
+    if (status) {
+      var text = STATUS_MESSAGE[String(status)] || (status >= 500 ? "The AI provider returned a server error." : "The AI provider rejected the request.");
+      return text + " (error " + status + ")" + (isTransientStatus(status) ? " This is usually temporary, please try again." : "");
+    }
     return "Something went wrong.";
   }
   function isErrorResponseBody(response) {
@@ -751,24 +769,63 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   // src/engine/budget.ts
   var CONTEXT_WINDOW_DEFAULT = { claude: 2e5, openai: 128e3 };
   var CONTEXT_WINDOW_BY_MODEL = {
-    "claude-opus-4-7": 2e5,
+    // exact ids
+    "claude-opus-5": 1e6,
+    "claude-opus-4-8": 1e6,
+    "claude-opus-4-7": 1e6,
+    "claude-sonnet-5": 1e6,
+    "claude-sonnet-4-6": 1e6,
     "claude-sonnet-4": 2e5,
-    "gpt-5.4": 128e3
+    "claude-haiku-4-5": 2e5,
+    "gpt-5.4": 128e3,
+    "gpt-5.6-luna": 128e3,
+    // family keys
+    "claude-opus": 1e6,
+    "claude-sonnet": 1e6,
+    "claude-haiku": 2e5,
+    "gpt-5.6": 128e3,
+    "gpt-5": 128e3
   };
+  var apiReportedContextWindows = {};
+  var projectContextWindows = {};
+  function setProjectContextWindow(serviceId, tokens) {
+    var key = (serviceId || "").trim();
+    if (!key) return;
+    var n = Number(tokens);
+    if (Number.isFinite(n) && n > 0) projectContextWindows[key] = Math.floor(n);
+    else delete projectContextWindows[key];
+  }
+  function getProjectContextWindow(serviceId) {
+    var key = (serviceId || "").trim();
+    return key && projectContextWindows[key] ? projectContextWindows[key] : null;
+  }
   var OUTPUT_TOKEN_RESERVE = 22e3;
   var TOOL_AND_RESPONSE_BUFFER = 4e3;
   var MIN_INPUT_TOKEN_BUDGET = 8e3;
   var CLAUDE_PER_REQUEST_INPUT_CAP = 28e3;
+  var MAX_HISTORY_MESSAGES = 20;
   var HISTORY_TOKEN_BUDGET = 8e3;
+  var CLAUDE_INPUT_CAP_RATIO = 0.16;
+  var HISTORY_BUDGET_RATIO = 0.08;
   function estimateTextTokens(text) {
     return Math.ceil((text || "").length / 3);
   }
   function estimateMessageTokens(msg) {
     return estimateTextTokens(msg.content) + estimateTextTokens(msg.role) + 6;
   }
-  function getContextWindow(platform, model) {
+  function getContextWindow(platform, model, serviceId) {
+    var override = serviceId ? getProjectContextWindow(serviceId) : null;
+    if (override) return override;
     var normalized = (model || "").trim().toLowerCase();
-    if (normalized && CONTEXT_WINDOW_BY_MODEL[normalized]) return CONTEXT_WINDOW_BY_MODEL[normalized];
+    if (normalized) {
+      if (apiReportedContextWindows[normalized]) return apiReportedContextWindows[normalized];
+      if (CONTEXT_WINDOW_BY_MODEL[normalized]) return CONTEXT_WINDOW_BY_MODEL[normalized];
+      var parts = normalized.split("-");
+      for (var end = parts.length - 1; end > 0; end--) {
+        var family = parts.slice(0, end).join("-");
+        if (CONTEXT_WINDOW_BY_MODEL[family]) return CONTEXT_WINDOW_BY_MODEL[family];
+      }
+    }
     return CONTEXT_WINDOW_DEFAULT[platform];
   }
   function stripFileBlocksFromHistory(content) {
@@ -776,15 +833,19 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     return content.replace(/```([^\n`]+?\.[^\s.`]+)\n[\s\S]*?```/g, "[file previously attached: $1]");
   }
   function buildBoundedChatMessages(options) {
-    var contextWindow = getContextWindow(options.platform, options.model);
+    var contextWindow = getContextWindow(options.platform, options.model, options.serviceId);
     var contextBasedBudget = Math.max(
       MIN_INPUT_TOKEN_BUDGET,
       contextWindow - OUTPUT_TOKEN_RESERVE - TOOL_AND_RESPONSE_BUFFER
     );
-    var availableInputBudget = options.platform === "claude" ? Math.min(contextBasedBudget, CLAUDE_PER_REQUEST_INPUT_CAP) : contextBasedBudget;
+    var scaled = !!(options.serviceId && getProjectContextWindow(options.serviceId));
+    var claudeInputCap = scaled ? Math.max(CLAUDE_PER_REQUEST_INPUT_CAP, Math.round(contextBasedBudget * CLAUDE_INPUT_CAP_RATIO)) : CLAUDE_PER_REQUEST_INPUT_CAP;
+    var availableInputBudget = options.platform === "claude" ? Math.min(contextBasedBudget, claudeInputCap) : contextBasedBudget;
     var systemCost = estimateTextTokens(options.systemPrompt) + 12;
-    var budgetForHistory = Math.max(1e3, Math.min(HISTORY_TOKEN_BUDGET, availableInputBudget - systemCost));
-    var windowed = options.history.slice(-20);
+    var historyAllowance = scaled ? Math.max(HISTORY_TOKEN_BUDGET, Math.round(contextBasedBudget * HISTORY_BUDGET_RATIO)) : HISTORY_TOKEN_BUDGET;
+    var budgetForHistory = Math.max(1e3, Math.min(historyAllowance, availableInputBudget - systemCost));
+    var maxHistoryMessages = scaled ? Math.max(MAX_HISTORY_MESSAGES, Math.round(MAX_HISTORY_MESSAGES * (budgetForHistory / HISTORY_TOKEN_BUDGET))) : MAX_HISTORY_MESSAGES;
+    var windowed = options.history.slice(-maxHistoryMessages);
     var latestIndex = windowed.length - 1;
     var trimmed = windowed.map(function(m, i2) {
       if (i2 === latestIndex) return m;
@@ -809,6 +870,163 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     };
   }
 
+  // src/engine/download_encoding.ts
+  var BOM = "\uFEFF";
+  var BOM_EXTS = /* @__PURE__ */ new Set(["csv", "tsv", "tab", "txt", "text", "log"]);
+  var HTML_EXTS = /* @__PURE__ */ new Set(["html", "htm", "xhtml"]);
+  var XML_EXTS = /* @__PURE__ */ new Set(["xml", "svg", "rss", "atom", "xsl", "xslt", "plist", "kml"]);
+  var RTF_EXTS = /* @__PURE__ */ new Set(["rtf"]);
+  var EXT_CONTENT_TYPES = {
+    csv: "text/csv; charset=utf-8",
+    tsv: "text/tab-separated-values; charset=utf-8",
+    tab: "text/tab-separated-values; charset=utf-8",
+    txt: "text/plain; charset=utf-8",
+    text: "text/plain; charset=utf-8",
+    log: "text/plain; charset=utf-8",
+    md: "text/markdown; charset=utf-8",
+    markdown: "text/markdown; charset=utf-8",
+    json: "application/json; charset=utf-8",
+    jsonl: "application/x-ndjson; charset=utf-8",
+    ndjson: "application/x-ndjson; charset=utf-8",
+    geojson: "application/geo+json; charset=utf-8",
+    yaml: "text/yaml; charset=utf-8",
+    yml: "text/yaml; charset=utf-8",
+    toml: "text/plain; charset=utf-8",
+    ini: "text/plain; charset=utf-8",
+    sql: "text/plain; charset=utf-8",
+    html: "text/html; charset=utf-8",
+    htm: "text/html; charset=utf-8",
+    xhtml: "application/xhtml+xml; charset=utf-8",
+    xml: "application/xml; charset=utf-8",
+    svg: "image/svg+xml; charset=utf-8",
+    css: "text/css; charset=utf-8",
+    js: "text/javascript; charset=utf-8",
+    ts: "text/plain; charset=utf-8",
+    py: "text/x-python; charset=utf-8",
+    sh: "text/x-shellscript; charset=utf-8",
+    srt: "application/x-subrip; charset=utf-8",
+    vtt: "text/vtt; charset=utf-8",
+    ics: "text/calendar; charset=utf-8",
+    vcf: "text/vcard; charset=utf-8",
+    // RTF is 7-bit ASCII by specification, so it takes no charset parameter.
+    rtf: "application/rtf",
+    // Binary types the model can only ever REFERENCE, never author in a fence, but
+    // which keep the type sensible if one ever shows up.
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp"
+  };
+  function normalizeExt(ext) {
+    return String(ext || "").trim().replace(/^\./, "").toLowerCase();
+  }
+  function extOf(filename) {
+    const name = String(filename || "");
+    const dot = name.lastIndexOf(".");
+    return dot > 0 ? normalizeExt(name.slice(dot + 1)) : "";
+  }
+  function encodingClassForExt(ext) {
+    const e = normalizeExt(ext);
+    if (BOM_EXTS.has(e)) return "bom";
+    if (HTML_EXTS.has(e)) return "html";
+    if (XML_EXTS.has(e)) return "xml";
+    if (RTF_EXTS.has(e)) return "rtf";
+    return "none";
+  }
+  function contentTypeForExt(ext, fallback = "text/plain; charset=utf-8") {
+    return EXT_CONTENT_TYPES[normalizeExt(ext)] || fallback;
+  }
+  function hasBom(text) {
+    return typeof text === "string" && text.charCodeAt(0) === 65279;
+  }
+  var HTML_HEAD_WINDOW = 4096;
+  var META_CHARSET_RE = /<meta[^>]+charset\s*=\s*["']?\s*([a-z0-9_-]+)/i;
+  var META_HTTP_EQUIV_RE = /<meta[^>]+http-equiv\s*=\s*["']?content-type["']?[^>]*>/i;
+  function ensureHtmlCharset(text) {
+    const src = String(text == null ? "" : text);
+    const head = src.slice(0, HTML_HEAD_WINDOW);
+    const declared = META_CHARSET_RE.exec(head);
+    if (declared) {
+      if (declared[1].toLowerCase().replace(/[^a-z0-9]/g, "") === "utf8") return src;
+      const start = declared.index + declared[0].length - declared[1].length;
+      return src.slice(0, start) + "utf-8" + src.slice(start + declared[1].length);
+    }
+    const httpEquiv = META_HTTP_EQUIV_RE.exec(head);
+    if (httpEquiv) {
+      return src.slice(0, httpEquiv.index) + '<meta charset="utf-8">' + src.slice(httpEquiv.index + httpEquiv[0].length);
+    }
+    const tag = '<meta charset="utf-8">';
+    const headOpen = /<head[^>]*>/i.exec(head);
+    if (headOpen) {
+      const at = headOpen.index + headOpen[0].length;
+      return src.slice(0, at) + "\n" + tag + src.slice(at);
+    }
+    const htmlOpen = /<html[^>]*>/i.exec(head);
+    if (htmlOpen) {
+      const at = htmlOpen.index + htmlOpen[0].length;
+      return src.slice(0, at) + "\n<head>" + tag + "</head>" + src.slice(at);
+    }
+    const doctype = /<!doctype[^>]*>/i.exec(head);
+    if (doctype) {
+      const at = doctype.index + doctype[0].length;
+      return src.slice(0, at) + "\n" + tag + src.slice(at);
+    }
+    return tag + "\n" + src;
+  }
+  var XML_DECL_RE = /^\s*<\?xml\s[^?]*\?>/i;
+  function ensureXmlEncoding(text) {
+    const src = String(text == null ? "" : text);
+    const decl = XML_DECL_RE.exec(src);
+    if (!decl) return src;
+    const found = /encoding\s*=\s*["']([^"']*)["']/i.exec(decl[0]);
+    if (!found) return src;
+    if (found[1].toLowerCase().replace(/[^a-z0-9]/g, "") === "utf8") return src;
+    const fixedDecl = decl[0].slice(0, found.index) + found[0].replace(found[1], "UTF-8") + decl[0].slice(found.index + found[0].length);
+    return fixedDecl + src.slice(decl[0].length);
+  }
+  var RTF_SIGNATURE_RE = /^[\s]*\{\\rtf/i;
+  function looksLikeRtf(text) {
+    return RTF_SIGNATURE_RE.test(String(text == null ? "" : text));
+  }
+  function escapeRtfNonAscii(text) {
+    const src = String(text == null ? "" : text);
+    let out = "";
+    let plainFrom = 0;
+    for (let i = 0; i < src.length; i++) {
+      const code = src.charCodeAt(i);
+      if (code < 128) continue;
+      out += src.slice(plainFrom, i);
+      out += `\\u${code > 32767 ? code - 65536 : code}?`;
+      plainFrom = i + 1;
+    }
+    return plainFrom === 0 ? src : out + src.slice(plainFrom);
+  }
+  function applyEncodingDeclaration(text, ext) {
+    const src = String(text == null ? "" : text);
+    switch (encodingClassForExt(ext)) {
+      case "bom":
+        return hasBom(src) ? src : BOM + src;
+      case "html":
+        return ensureHtmlCharset(src);
+      case "xml":
+        return ensureXmlEncoding(src);
+      case "rtf":
+        return looksLikeRtf(src) ? escapeRtfNonAscii(src) : hasBom(src) ? src : BOM + src;
+      default:
+        return src;
+    }
+  }
+  function prepareDownloadText(filename, body) {
+    const ext = extOf(filename);
+    return {
+      ext,
+      text: applyEncodingDeclaration(body, ext),
+      contentType: contentTypeForExt(ext)
+    };
+  }
+
   // src/engine/time.ts
   function wallClockNow() {
     return Date.now();
@@ -829,6 +1047,31 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
   }
 
+  // src/engine/ai_agent.ts
+  function normalizePlatform(raw) {
+    var p = (raw || "").trim().toLowerCase();
+    return p === "claude" || p === "openai" ? p : null;
+  }
+  function parseAiAgentValue(value) {
+    var raw = (value || "").trim();
+    if (!raw || raw.toLowerCase() === "none") {
+      return { platform: null, model: "", contextWindow: null, hasPlatform: false };
+    }
+    var firstHash = raw.indexOf("#");
+    if (firstHash === -1) {
+      var only = normalizePlatform(raw);
+      return { platform: only, model: "", contextWindow: null, hasPlatform: !!only };
+    }
+    var platform = normalizePlatform(raw.slice(0, firstHash));
+    var rest = raw.slice(firstHash + 1);
+    var secondHash = rest.indexOf("#");
+    var model = (secondHash === -1 ? rest : rest.slice(0, secondHash)).trim();
+    var windowRaw = secondHash === -1 ? "" : rest.slice(secondHash + 1).trim();
+    var parsedWindow = windowRaw ? Number(windowRaw) : NaN;
+    var contextWindow = Number.isFinite(parsedWindow) && parsedWindow > 0 ? Math.floor(parsedWindow) : null;
+    return { platform, model, contextWindow, hasPlatform: !!platform };
+  }
+
   // src/engine/requests.ts
   var ANTHROPIC_MESSAGES_API_URL = "https://api.anthropic.com/v1/messages";
   var ANTHROPIC_VERSION = "2023-06-01";
@@ -945,7 +1188,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       return { ...m, content: blocks };
     });
   }
-  var POLL_INTERVAL = 1500;
+  var POLL_INTERVAL = 3e3;
   async function callClaudeWithMcp({
     prompt,
     messages,
@@ -1310,7 +1553,8 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         method: "POST"
       },
       { service: params.service, owner: params.owner },
-      params.queue ? { queue: params.queue } : {}
+      params.queue ? { queue: params.queue } : {},
+      params.status ? { status: params.status } : {}
     );
     return chatEngineConfig().clientSecretRequestHistory(
       p,
@@ -1347,6 +1591,25 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     return "";
   }
+  function isIndexingRequestText(userText) {
+    if (typeof userText !== "string") return false;
+    return userText.indexOf("A new file has just been uploaded") === 0 || userText.indexOf("CONTINUE indexing") === 0;
+  }
+  function parseIndexingRequestText(userText) {
+    if (typeof userText !== "string" || !userText) return null;
+    var nameMatch = userText.match(/^- name: (.+)$/m);
+    if (!nameMatch) return null;
+    var mimeMatch = userText.match(/^- mime type: (.+)$/m);
+    var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
+    var pathMatch = userText.match(/^- storage path: (.+)$/m);
+    return {
+      name: nameMatch[1].trim(),
+      path: pathMatch ? pathMatch[1].trim() : void 0,
+      mime: mimeMatch ? mimeMatch[1].trim() : void 0,
+      size: sizeMatch ? Number(sizeMatch[1]) : void 0,
+      continued: userText.indexOf("CONTINUE indexing") === 0
+    };
+  }
   function mapHistoryListToMessages(list, platform, opts) {
     var mapped = [], runningItemIds = [];
     var extractAssistantText = platform === "openai" ? extractOpenAIText : extractClaudeText;
@@ -1371,27 +1634,17 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         var displayContent;
         var indexFile = void 0;
         if (item._isBgTask) {
-          var nameMatch = userText.match(/^- name: (.+)$/m);
-          if (nameMatch) {
-            var mimeMatch = userText.match(/^- mime type: (.+)$/m);
-            var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
-            var pathMatch = userText.match(/^- storage path: (.+)$/m);
-            var isContinuePass = userText.indexOf("CONTINUE indexing") === 0;
+          var ref = parseIndexingRequestText(userText);
+          if (ref) {
             displayContent = opts.formatIndexingLabel(
-              nameMatch[1].trim(),
-              mimeMatch ? mimeMatch[1].trim() : "",
-              sizeMatch ? Number(sizeMatch[1]) : null,
-              pathMatch ? pathMatch[1].trim() : void 0,
+              ref.name,
+              ref.mime || "",
+              typeof ref.size === "number" ? ref.size : null,
+              ref.path,
               false,
-              isContinuePass
+              ref.continued
             );
-            indexFile = {
-              name: nameMatch[1].trim(),
-              path: pathMatch ? pathMatch[1].trim() : void 0,
-              mime: mimeMatch ? mimeMatch[1].trim() : void 0,
-              size: sizeMatch ? Number(sizeMatch[1]) : void 0,
-              continued: isContinuePass
-            };
+            indexFile = ref;
           } else {
             displayContent = userText;
           }
@@ -1520,6 +1773,8 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   }
 
   // src/engine/session.ts
+  var WORKER_PASS_ADOPT_LIMIT = 20;
+  var WORKER_PASS_ADOPT_ATTEMPTS = [0, 2e3, 6e3];
   var _g = typeof globalThis !== "undefined" ? globalThis : {};
   function nowMs() {
     return _g.performance && typeof _g.performance.now === "function" ? _g.performance.now() : Date.now();
@@ -1539,6 +1794,35 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   var ChatSession = class {
     constructor(host) {
       this.typewriterQueue = Promise.resolve();
+      /**
+       * Pick up indexing passes the WORKER minted, which no client ever dispatched.
+       *
+       * For a PDF (and for text/grid when windowed indexing is on) the worker writes
+       * pass N+1's row itself, inside pass N's invocation, right after saving pass
+       * N's result. That row reaches this client through nothing at all: it is not in
+       * bgTaskQueue (the client never asked for it) and it is not in state.messages
+       * (only a first-page history load maps it in, which happens on mount, project
+       * switch or tab return). So between two worker passes every pass the client
+       * knows about is settled, and the collapsed row renders "Indexed  N passes"
+       * with no spinner and no Stop, for a file that is still being read. A user who
+       * believes that then asks questions against a half-indexed file — which is what
+       * this exists to prevent.
+       *
+       * So when a background indexing pass settles, ask the bg queue what is still
+       * unresolved on it and adopt anything unknown as an ordinary BgTaskEntry.
+       * drainBgTaskQueue then treats it exactly like a pass this client dispatched:
+       * same bubble, same `_indexFile` (so it joins the file's collapsed row), same
+       * poll — and that poll settling runs this again, so the chain is followed to
+       * its end. `status`-scoped so the reply carries the live items only, never a
+       * page of finished ones with their bodies.
+       *
+       * Termination: the only trigger is a pass SETTLING, which happens once per
+       * pass. An adopted item that is still running is not re-adopted (its id is
+       * already polled), and when the queue holds nothing unknown the chain stops on
+       * its own. Nothing here is periodic — a timer that re-reads history is the
+       * shape that previously looped fetchHistoryPage after an already-DONE index.
+       */
+      this._adoptingWorkerPasses = false;
       this.host = host;
       this.state = {
         messages: [],
@@ -1828,7 +2112,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var chatQueue = useBgQueue ? userId + BG_INDEXING_QUEUE_SUFFIX : userId;
       if (offChat) {
         var offHistory = (this.aiChatHistoryCache[key] ? this.aiChatHistoryCache[key].messages : []).filter(function(m) {
-          return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask;
+          return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask && !m.isError;
         });
         var offBounded = buildBoundedChatMessages({
           platform: aiPlatform,
@@ -1863,7 +2147,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }
       if (isQueuedSend) {
         var resolvedHistory = this.state.messages.filter(function(m) {
-          return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask;
+          return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask && !m.isError;
         });
         var boundedQ = buildBoundedChatMessages({
           platform: aiPlatform,
@@ -1914,7 +2198,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.state.sending = true;
       this.host.scrollToBottom(true);
       var historyForLlm = this.state.messages.filter(function(m) {
-        return !m.isCancelled && !m.isBackgroundTask;
+        return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask && !m.isError;
       });
       if (llmComposed !== composed) {
         for (var li = historyForLlm.length - 1; li >= 0; li--) {
@@ -2484,8 +2768,21 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     // --- background-task resolution + drain -------------------------------
     handleHistoryItemResolution(itemId, response, platform) {
+      var indexRef = this._indexRefOfItem(itemId);
       this.applyHistoryItemResolution(itemId, response, platform);
       this.promoteNextBgQueuedToRunning();
+      if (indexRef) this._followWorkerIndexingChain(indexRef.name, indexRef.mime);
+    }
+    /** The file an already-rendered background pass is about, off its request
+     *  bubble. Null for an ordinary turn, which is most of them. */
+    _indexRefOfItem(itemId) {
+      if (!itemId) return null;
+      for (var i = 0; i < this.state.messages.length; i++) {
+        var m = this.state.messages[i];
+        if (m._serverItemId !== itemId || m.role !== "user" || !m.isBackgroundTask) continue;
+        return m._indexFile || null;
+      }
+      return null;
     }
     applyHistoryItemResolution(itemId, response, platform) {
       this.historyItemPolls.delete(itemId);
@@ -2619,6 +2916,116 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         self.cancelQueuedMessage(t.msg, idx === -1 ? t.idx : idx);
       });
     }
+    /**
+     * True when the WORKER, not this client, drives the rest of this file's chain.
+     * The mirror image of the early returns in maybeResumeIndexing: whatever that
+     * refuses to continue is exactly what nothing client-side is tracking.
+     */
+    _isWorkerDrivenIndexing(filename, mime) {
+      if (!isPagedReadFile(filename, mime)) return false;
+      if (isImageVisionFile(filename, mime)) return true;
+      return windowedIndexingEnabled() && isWindowedReadFile(filename, mime);
+    }
+    _adoptWorkerIndexingPasses(attempt) {
+      var self = this;
+      if (this._adoptingWorkerPasses) return;
+      var id = this.host.getIdentity();
+      var platform = id.platform;
+      if (!id.serviceId || platform !== "claude" && platform !== "openai") return;
+      if (this.isPollingPaused() || !this.host.isViewMounted()) return;
+      var svcId = id.serviceId, owner = id.owner;
+      var queue = (id.userId || id.serviceId) + BG_INDEXING_QUEUE_SUFFIX;
+      var ask = function(status) {
+        return Promise.resolve(getChatHistory(
+          { service: svcId, owner, platform, queue, status },
+          { limit: WORKER_PASS_ADOPT_LIMIT }
+        )).catch(function() {
+          return null;
+        });
+      };
+      this._adoptingWorkerPasses = true;
+      Promise.all([ask("running"), ask("pending")]).then(function(results) {
+        self._adoptingWorkerPasses = false;
+        var now = self.host.getIdentity();
+        if (now.serviceId !== svcId || now.platform !== platform) return;
+        if (!self.host.isViewMounted()) return;
+        var adoptedIds = [];
+        for (var ri = 0; ri < results.length; ri++) {
+          var list = results[ri] && Array.isArray(results[ri].list) ? results[ri].list : [];
+          for (var i = 0; i < list.length; i++) {
+            if (self._adoptWorkerIndexingItem(list[i], svcId, platform)) adoptedIds.push(list[i].id);
+          }
+        }
+        if (adoptedIds.length) {
+          self.drainBgTaskQueue();
+          if (self._isTrackingAny(adoptedIds)) return;
+        }
+        if (attempt + 1 >= WORKER_PASS_ADOPT_ATTEMPTS.length) return;
+        setTimeout(function() {
+          var later = self.host.getIdentity();
+          if (later.serviceId !== svcId || later.platform !== platform) return;
+          if (self.isPollingPaused() || !self.host.isViewMounted()) return;
+          self._adoptWorkerIndexingPasses(attempt + 1);
+        }, WORKER_PASS_ADOPT_ATTEMPTS[attempt + 1]);
+      }, function() {
+        self._adoptingWorkerPasses = false;
+      });
+    }
+    /** Any of these ids still queued or still polled, i.e. surviving work. */
+    _isTrackingAny(ids) {
+      for (var i = 0; i < ids.length; i++) {
+        if (this.historyItemPolls.has(ids[i])) return true;
+        for (var q = 0; q < this.bgTaskQueue.length; q++) {
+          if (this.bgTaskQueue[q].id === ids[i]) return true;
+        }
+      }
+      return false;
+    }
+    /** One live bg-queue item -> a BgTaskEntry, if it is an indexing pass this
+     *  client is not already tracking. Returns whether it was adopted. */
+    _adoptWorkerIndexingItem(item, svcId, platform) {
+      if (!item || typeof item.id !== "string" || !item.id) return false;
+      if (item.status !== "pending" && item.status !== "running") return false;
+      if (typeof item.poll !== "function") return false;
+      if (this.historyItemPolls.has(item.id)) return false;
+      for (var q = 0; q < this.bgTaskQueue.length; q++) {
+        if (this.bgTaskQueue[q].id === item.id) return false;
+      }
+      for (var m = 0; m < this.state.messages.length; m++) {
+        var msg = this.state.messages[m];
+        if (msg._serverItemId !== item.id) continue;
+        if (!(msg.isPending || msg.isPendingInProcess || msg.isPendingQueued)) return false;
+      }
+      var body = item.request_body;
+      if (!body || typeof body !== "object") return false;
+      if (platform === "claude" ? !Array.isArray(body.messages) : !Array.isArray(body.input)) return false;
+      var userText = extractLastUserTextFromRequest(body);
+      if (!isIndexingRequestText(userText)) return false;
+      var ref = parseIndexingRequestText(userText);
+      if (!ref || !ref.name) return false;
+      if (!this._isWorkerDrivenIndexing(ref.name, ref.mime)) return false;
+      this.bgTaskQueue.push({
+        serviceId: svcId,
+        platform,
+        id: item.id,
+        filename: ref.name,
+        storagePath: ref.path,
+        mime: ref.mime,
+        size: ref.size,
+        status: item.status === "running" ? "running" : "pending",
+        poll: item.poll,
+        // Drives the "(continuing)" label and marks this as a continuation for
+        // _applyIndexCancellations, which must not read a CONTINUE pass as the
+        // fresh first pass that lifts a stop.
+        resumePass: ref.continued ? 1 : 0
+      });
+      return true;
+    }
+    /** Follow the chain on from a background indexing pass that just settled. */
+    _followWorkerIndexingChain(filename, mime) {
+      if (!this._isWorkerDrivenIndexing(filename, mime)) return;
+      this._adoptWorkerIndexingPasses(0);
+    }
     /** Best-effort server-side cancel of a bg-queue item that has no bubble (so
      *  cancelQueuedMessage, which drives one, has nothing to act on). */
     _cancelServerItem(serverId) {
@@ -2829,8 +3236,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         var chatList = history && Array.isArray(history.list) ? history.list : [];
         chatList.forEach(function(item) {
           if (isBgIndexingQueue(item.queue_name)) {
-            var userText = extractLastUserTextFromRequest(item.request_body);
-            if (typeof userText === "string" && (userText.indexOf("A new file has just been uploaded") === 0 || userText.indexOf("CONTINUE indexing") === 0)) item._isBgTask = true;
+            if (isIndexingRequestText(extractLastUserTextFromRequest(item.request_body))) item._isBgTask = true;
             else item._isOnBgQueue = true;
           }
         });
@@ -3401,7 +3807,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.8.0" ;
+    var BQ_VERSION = "1.8.2" ;
     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";
@@ -5287,13 +5693,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var key = filename + "\0" + body;
       var existing = fileBlobCache.get(key);
       if (existing) return existing;
-      var contentType = mimeGetType(filename) || "text/plain";
-      var ext = (String(filename || "").split(".").pop() || "").toLowerCase();
-      var isText = /^text\//i.test(contentType) || /application\/(json|xml|csv|yaml|x-yaml|javascript)/i.test(contentType);
-      var needsBom = ext === "csv" || ext === "tsv" || ext === "tab";
-      var type = isText ? contentType + "; charset=utf-8" : contentType;
-      var data = needsBom ? "\uFEFF" + body : body;
-      var href = URL.createObjectURL(new Blob([data], { type }));
+      var prepared = prepareDownloadText(filename, body);
+      var type = EXT_CONTENT_TYPES[extOf(filename)] || mimeGetType(filename) || "text/plain; charset=utf-8";
+      var href = URL.createObjectURL(new Blob([prepared.text], { type }));
       fileBlobCache.set(key, href);
       return href;
     }
@@ -6703,7 +7105,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       if (S.aiPlatform === "none") return "No agent configured";
       return S.serviceName || "BunnyQuery";
     }
-    function parseAiAgentValue(value) {
+    function parseAiAgentValue2(value) {
       var raw = (value || "").trim();
       var platform = raw, model = "";
       if (raw.indexOf("#") !== -1) {
@@ -6717,9 +7119,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     function applyAgentConfig() {
       var conn = S.service || {};
       var raw = conn.ai_agent || "";
-      var parsed = parseAiAgentValue(raw);
+      var parsed = parseAiAgentValue2(raw);
       S.aiPlatform = parsed.platform;
       S.aiModel = parsed.model;
+      setProjectContextWindow(S.serviceId, parseAiAgentValue(raw).contextWindow);
       S.serviceName = conn.service_name || "";
       S.serviceDescription = conn.service_description || "";
     }
@@ -6861,6 +7264,15 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         },
         mcpBaseUrl: mcpBaseUrl(),
         poll: 0,
+        // Server-driven windowed indexing. Off by default in the engine because the
+        // worker must strip `_skapi_window` first, or the provider rejects the whole
+        // call with no retry. `apply_file_windows` is deployed in every region
+        // (verified 2026-07-27 against the deployed ClientSecretKeyPollingWorker in
+        // all 7), so the widget now opts in like agent.vue does. Without it the
+        // widget fell back to the client-driven CONTINUE loop capped at
+        // MAX_INDEXING_RESUME_PASSES, which needs the tab kept open and stops early
+        // on a big file. Pass windowedIndexing: false in init opts to opt back out.
+        windowedIndexing: S.opts.windowedIndexing !== false,
         // Client-side attachment parsers (e.g. an .hwp parser) passed via init opts.
         attachmentParsers: S.opts.attachmentParsers || void 0
       });