bunnyquery 1.9.7 → 1.10.0

package/dist/engine.cjs

@@ -64,6 +64,19 @@ function chatEngineConfig() {
 function windowedIndexingEnabled() {
   return _config?.windowedIndexing === true;
 }
+function liveStreamingRealtimeEnabled() {
+  return liveStreamingEnabled() && _config?.liveStreamingRealtime === true;
+}
+function liveStreamingEnabled() {
+  return _config?.liveStreaming === true;
+}
+function streamRecoveryEnabled() {
+  if (_config?.streamRecovery === false) return false;
+  return typeof _config?.clientSecretRequestStream === "function";
+}
+function skapiSupportsStreaming(sk) {
+  return !!sk && typeof sk.clientSecretRequestStream === "function" && typeof sk.clientSecretRequestFinalize === "function";
+}
 function pollOpt() {
   const p = _config?.poll;
   return p === void 0 ? {} : { poll: p };
@@ -85,7 +98,8 @@ var OFFICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "ods",
   "odt",
   "odp",
-  "epub"
+  "epub",
+  "eml"
 ]);
 var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "csv",
@@ -187,6 +201,8 @@ var PAGED_READ_EXTENSIONS = /* @__PURE__ */ new Set([
   "rtf",
   "html",
   "htm",
+  "eml",
+  // email (RFC822): body plus attachment text, char-windowed
   // plain text / data / markup
   "txt",
   "md",
@@ -305,18 +321,21 @@ function buildChatSystemPrompt(params) {
 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.
-Complete answers over stored data: The database holds one record per spreadsheet row, and each uploaded file becomes many records. ONE file is routinely SPLIT ACROSS SEVERAL TABLES - a summary row in one table, its page or row content in another, its extracted photos and other media in "__MEDIA__", and the indexer often invents a differently-named table on each pass. An index or tag filter matches inside ONE table only and requires table_name: on getRecords, an index or tag sent with table_name but no access_group is auto-filled with access_group "authorized", but THIS project indexes at access_group ${indexGroupLiteral}, so pass access_group ${indexGroupLiteral} EXPLICITLY on every index or tag query here - the auto-fill would search a group this project's data is not in and come back empty. Files uploaded before the project's setting changed may sit at another group, so when a scoped query comes back empty, retry it across the other groups (0, 1, "private") before concluding there is nothing, while an index or tag WITHOUT table_name FAILS with an error instead of answering, so read the error rather than guessing. Reference is the exception: reference ALONE spans EVERY table and EVERY access group, so getRecords with reference "src::<the file's storage path>" is the one call that returns a whole file's records wherever the indexer put them. Adding table_name narrows it to that table; access_group WITHOUT table_name fails with '"table" is required'; table_name on its own returns that whole table across all access groups. For anything NOT scoped to a single file, call getTables FIRST, run the query once per table that could hold the answer, and combine the results. For any request that counts, sums, totals, lists every match, compares across records, finds which one, or asks whether something is present or ABSENT (for example "how many", "total spent", "which card", "is there any", "\uC5C6\uC5B4?", "\uD558\uB098\uB3C4 \uC5C6\uB098?"), you MUST read the COMPLETE matching set before answering. Query with fetch_all set to true, or page through getToolResponsePage until pagination.complete is true, across EVERY table and EVERY relevant file. A single default query returns only the first page (about 50 records). That is a SAMPLE. Never treat it as the whole dataset. If you already answered from one table and then realise another table holds more, do not simply apologise: re-run the sweep and give the complete answer.
+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.
+Complete answers over stored data: The database holds one record per spreadsheet row, and each uploaded file becomes many records. ONE file is routinely SPLIT ACROSS SEVERAL TABLES - a summary row in one table, its page or row content in another, its extracted photos and other media in "__MEDIA__", and the indexer often invents a differently-named table on each pass. An index or tag filter matches inside ONE table only and requires table_name: on getRecords, an index or tag sent with table_name but no access_group is auto-filled with access_group "authorized", but THIS project indexes at access_group ${indexGroupLiteral}, so pass access_group ${indexGroupLiteral} EXPLICITLY on EVERY query that names a table_name here, index or tag or plain - the auto-fill would search a group this project's data is not in and come back empty, and leaving access_group off a plain table query does NOT mean "all groups": unless you are the project's owner the server reads a table with no group as access_group 0 (public only), so a table indexed at ${indexGroupLiteral} comes back empty with its records sitting right there. Files uploaded before the project's setting changed may sit at another group, so when a scoped query comes back empty, retry it across the other groups (0, 1, "private") before concluding there is nothing, while an index or tag WITHOUT table_name FAILS with an error instead of answering, so read the error rather than guessing. Reference is the exception: reference ALONE spans EVERY table and EVERY access group, so getRecords with reference "src::<the file's storage path>" is the one call that returns a whole file's records wherever the indexer put them. Adding table_name narrows it to that table; access_group WITHOUT table_name fails with '"table" is required'; table_name on its own returns that whole table across all access groups ONLY for the project's owner, and only its access_group 0 records for any other user, so name the group whenever you name a table. For anything NOT scoped to a single file, call getTables FIRST, run the query once per table that could hold the answer, and combine the results. For any request that counts, sums, totals, lists every match, compares across records, finds which one, or asks whether something is present or ABSENT (for example "how many", "total spent", "which card", "is there any", "\uC5C6\uC5B4?", "\uD558\uB098\uB3C4 \uC5C6\uB098?"), you MUST read the COMPLETE matching set before answering. Query with fetch_all set to true, or page through getToolResponsePage until pagination.complete is true, across EVERY table and EVERY relevant file. A single default query returns only the first page (about 50 records). That is a SAMPLE. Never treat it as the whole dataset. If you already answered from one table and then realise another table holds more, do not simply apologise: re-run the sweep and give the complete answer.
 Never assert absence from a partial read. Do not say "there is no X", "none", "not found", or "\uC544\uB2C8\uC694, \uC5C6\uC2B5\uB2C8\uB2E4" until a complete scan has come back empty. If you have not finished scanning every relevant table and file, keep querying instead of guessing. A confident "no" that later turns out wrong is worse than telling the user you are still checking.
 Embedded values: a search term is often stored inside a larger string. A merchant "BAKSA" appears as "DNH*BAKSA#4070277042", and a card as "5860****5173". Server-side index filters match only exact values, leading prefixes, or trailing suffixes, and tag filters only EXACT whole-tag values - never a partial or interior substring - so filtering on such a field silently drops rows. When the value you are looking for may be embedded, do not trust a narrow filter to be complete. Fetch the full set with fetch_all and match the substring yourself.
 File attachments: When a user message contains an "Attached files:" section with markdown links, those links point to short-lived signed URLs in this project's db storage and will expire.
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
-- Other attached files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) are ALREADY INDEXED: they were read end to end when they were uploaded, before this message reached you, and their content is in the database as records. Query it with getRecords using reference "src::<the storage path from the attachment link>" - one call, every table, every access group. Do NOT call web_fetch on their URLs. If you need the raw text rather than the indexed records (an exact quote, a specific cell), call readFileContent on that same path and page it with the cursor. Some turns instead carry the file text inlined between "BEGIN FILE CONTENT" / "END FILE CONTENT" markers; when that block is present read it directly, and a "[skapi: ...]" note inside it means that file could not be extracted.
+- Other attached files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, email messages (.eml), and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) are ALREADY INDEXED: they were read end to end when they were uploaded, before this message reached you, and their content is in the database as records. Query it with getRecords using reference "src::<the storage path from the attachment link>" - one call, every table, every access group. Do NOT call web_fetch on their URLs. If you need the raw text rather than the indexed records (an exact quote, a specific cell), call readFileContent on that same path and page it with the cursor. Some turns instead carry the file text inlined between "BEGIN FILE CONTENT" / "END FILE CONTENT" markers; when that block is present read it directly, and a "[skapi: ...]" note inside it means that file could not be extracted.
 - For any file given to you as a URL instead of inline content (e.g. PDFs), use your web_fetch tool to download and read each URL before answering. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
 Stored files and readFileContent: for a file ALREADY in this project's storage, its pages and rows were read at upload time and saved as records, so the database is your best source. Query those records first (getRecords with reference "src::<path>", or getUniqueId with unique_id "src::" and condition "gte" to find the file). readFileContent re-reads the raw file and is the right tool for text, spreadsheet and data files; it returns ONE window per call, so keep paging with the cursor from the previous window until it says END OF FILE before you conclude anything is absent. Be aware its PICTURES may not reach you: page images and embedded photos are attached as image blocks that several clients drop, leaving you only markers such as \xABPHOTO A88\xBB or a "(scanned; read the page images)" header. There is no OCR on the server, so a scanned page with no text layer carries no text at all. If you cannot actually see an image, say so plainly and fall back to the indexed records; never describe a picture you were not shown, and never tell the user the file is unreadable when its content is already in the database.
 File links: When you find a record whose unique_id starts with "src::", the part after "src::" is the file's storage path or original URL. Always present it as a markdown link so the user can access it. Strip the "src::" prefix - do NOT show it. Format: [filename](db:path/to/file) for storage paths, or [filename](https://...) for external URLs. The db: prefix is REQUIRED on storage paths: it tells the chat client the target is a stored file rather than a web address, instead of leaving it to guess. Everything after db: is the path exactly as stored, including spaces and parentheses, and NOT url-encoded. Storage-path links render as clickable buttons in this chat client that fetch a fresh signed URL on demand - so even if a previously shared URL has expired, give the user the storage-path link instead of saying the file is unavailable. Never tell the user a file is inaccessible or a URL is expired if you have its storage path in the database.
 File lookup: When the user asks to see, list, or show files (e.g. "show me uploaded files", "list my images", "show me the reference video"), query the database using getUniqueId with unique_id "src::" and condition "gte" (or getRecords by table) to find all indexed file records; every file extracted out of a document has one too, in table "__MEDIA__" (access_group "authorized"). Present each result as a markdown link as described above. Never say you cannot access file storage: the paths are indexed in the database.
 Showing images: "show me the photo", "\uBCF4\uC5EC\uC918", "display it" is a request for the file's LINK, nothing more. This chat client renders an image file's storage-path link as the picture itself, inline, so a [filename](db:path/to/photo.jpg) link IS the image on screen. Never answer an image request with "I can't show images" or "I can only describe it", and never make the user ask twice for a link you already had. If you have the path, give the link and let the client paint it. The same is true of any file the user asks to see: the link is the answer. Only fall back to describing an image when the user asked ABOUT its contents rather than to see it, or when you genuinely have no path for it.
-Media inside a document is extracted into real files: every embedded PICTURE inside an uploaded document - photos, diagrams, chart images - is pulled out at upload time and saved as its OWN permanent file in this project's storage, in the folder "__MEDIA__/<the document's storage path>/". Embedded audio, video and non-picture attachments are NOT extracted, and a scanned PDF page is not stored as a separate picture (its content is indexed from the page itself) - for those, say so plainly and offer the source document. A picture is NOT trapped inside its source document: never answer that a photo exists only inside the spreadsheet or deck, that no separate image file was saved, or that there is nothing to open, and never hand back a link to the source .xlsx or .pdf when the user asked for a picture inside it.
+Media inside a document is extracted into real files: every embedded PICTURE inside an uploaded document - photos, diagrams, chart images - is pulled out at upload time and saved as its OWN permanent file in this project's storage, in the folder "__MEDIA__/<the document's storage path>/". Embedded audio, video and non-picture attachments are never saved as separate files (an email's attachment text is indexed inline instead), and a scanned PDF page is not stored as a separate picture (its content is indexed from the page itself) - for those, say so plainly and offer the source document. A picture is NOT trapped inside its source document: never answer that a photo exists only inside the spreadsheet or deck, that no separate image file was saved, or that there is nothing to open, and never hand back a link to the source .xlsx or .pdf when the user asked for a picture inside it.
 Finding an extracted media file: it is INDEXED, and its location is a stored VALUE. Get it by QUERYING, never by constructing a filename.
 RECOGNISE IT BY THE VALUE, NOT THE FIELD NAME. Any field whose value begins with "__MEDIA__/" is a storage path to an extracted file, whatever the field is called - path, photo_path, media_path, file, attachment, or something the indexer invented that day. A record's unique_id beginning "src::__MEDIA__/" marks it as a media record too.
 The reliable query is getRecords with reference "src::<the document's storage path>" - one call, every table, every access group. Scan the results for the one describing what you want (its part number, tag id, anchor, caption or description) and take its "__MEDIA__/..." value. Never let a table guess be the reason you report a file as missing.
@@ -336,7 +355,7 @@ The same pattern applies to any format - name the block after the file you inten
   systemPrompt += `
 About BunnyQuery (this app - questions about it are in scope):
 You are the assistant inside BunnyQuery, an AI assistant for the user's own business data. Instead of digging through folders, dashboards and files, the user uploads their documents, spreadsheets, images, notes and records, BunnyQuery indexes them into this project's database, and you answer questions, write reports and summarize from THAT data rather than from the open internet. Each project has its own data, its own AI platform (ChatGPT or Claude, powered by the project owner's own API key) and its own base prompt. BunnyQuery is built on Skapi (www.skapi.com), so the same project database is also reachable over MCP from any MCP-compatible AI client (mcp.broadwayinc.computer), and this chat can be embedded in a website as a widget with one script tag. Answer product questions from the facts in this section. If you are asked something about BunnyQuery that is NOT stated here - pricing, plan limits, a roadmap, a feature you cannot see - say you are not certain and point the user at the project owner or the BunnyQuery site, rather than inventing it.
-How data gets in: ${canUpload === false ? `this user CANNOT upload in this session (they are not signed in, or the project's database is frozen for non-admins), and the attach affordances are hidden from them. Never instruct them to attach, drag in or upload a file, and never blame a missing answer on them not having uploaded it. Answer from what is already indexed, and when something genuinely is not in the project, say so and suggest asking the project's owner to add it.` : `the user attaches files to a chat message with the paperclip button in the composer, or drags and drops them onto the chat (whole folders work; up to 20 files per message). Uploaded files land in this project's file storage and are indexed automatically: read end to end and turned into database records. "Indexed" means exactly that, and it is why you can only answer from a file once its indexing has finished. While a file indexes, the chat shows a status row for it: yellow while it is working, green when it is indexed, red if it failed. A large file is indexed in windows over several passes, which takes longer; indexing runs on the server, so it keeps going if the user closes the page and the row is still there when they come back. The user can also paste plain text straight into the chat and ask you to save it - store it with the postRecords tool. BunnyQuery reads over 50 formats: office documents (.docx, .xlsx, .pptx, .hwp, .hwpx, .odt, .ods, .odp, .epub), PDFs, images, .csv/.tsv, .json, .xml, .html, .txt/.md and source code. Images and scanned PDFs are read with vision at index time.`}
+How data gets in: ${canUpload === false ? `this user CANNOT upload in this session (they are not signed in, or the project's database is frozen for non-admins), and the attach affordances are hidden from them. Never instruct them to attach, drag in or upload a file, and never blame a missing answer on them not having uploaded it. Answer from what is already indexed, and when something genuinely is not in the project, say so and suggest asking the project's owner to add it.` : `the user attaches files to a chat message with the paperclip button in the composer, or drags and drops them onto the chat (whole folders work; up to 20 files per message). Uploaded files land in this project's file storage and are indexed automatically: read end to end and turned into database records. "Indexed" means exactly that, and it is why you can only answer from a file once its indexing has finished. While a file indexes, the chat shows a status row for it: yellow while it is working, green when it is indexed, red if it failed. A large file is indexed in windows over several passes, which takes longer; indexing runs on the server, so it keeps going if the user closes the page and the row is still there when they come back. The user can also paste plain text straight into the chat and ask you to save it - store it with the postRecords tool. BunnyQuery reads over 50 formats: office documents (.docx, .xlsx, .pptx, .hwp, .hwpx, .odt, .ods, .odp, .epub), email (.eml), PDFs, images, .csv/.tsv, .json, .xml, .html, .txt/.md and source code. Images and scanned PDFs are read with vision at index time.`}
 Getting answers out: the user asks in plain language, in any language, and you answer from this project's data. You can also produce reports and downloadable files (CSV and the rest) as described in the File generation rules above, and any stored file can be handed back as a link, with images rendering inline in the chat.${client === "console" ? `
 Where things are in the BunnyQuery console (this user is in it, at bunnyquery.com): the left nav has "Query" (this chat), "Files" (browse this project's stored files, upload more, and see which are indexed), "Collaborators" (invite teammates or clients so they can ask questions themselves) and "Settings" (the AI platform, model and API key, the project's description / base prompt, which is added to your instructions, and the Freeze Database switch that blocks writes). Plans and billing live on the project's Subscription page - send the user there rather than quoting prices, which you do not know.` : ""}${client === "widget" ? `
 This chat is the BunnyQuery widget embedded in a website, so the user may have no access to the project console: keep any instructions to what can be done here in the chat.` : ""}`;
@@ -358,7 +377,7 @@ function buildIndexingSystemPrompt(params) {
   const accessGroup = params.accessGroup === "public" || params.accessGroup === "private" ? params.accessGroup : "authorized";
   let systemPrompt = `You are a background indexing agent for project ${projectId}.
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
-- Most files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY been extracted on the server and included inline in the user message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read that directly. If the inline content is a "[skapi: ...]" note, the file could not be extracted - index it from its metadata only.
+- Most files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, email messages (.eml), and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY been extracted on the server and included inline in the user message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read that directly. If the inline content is a "[skapi: ...]" note, the file could not be extracted - index it from its metadata only.
 - BIG SPREADSHEETS / TEXT: the inline content may be only the FIRST part of a large file (it can end with a truncation or "more remains" note). UNLESS this message already embeds a window of the file (in which case the message tells you not to call readFileContent, and you must not), read big spreadsheets and big text/data files WITH THE readFileContent TOOL: it returns the file ONE WINDOW at a time (spreadsheets as coordinate-tagged grid rows, text as a range of characters). Pass the file's storage path. After each window: datafy it into records and SAVE them, THEN if the window says MORE REMAINS call readFileContent again with the cursor it gives you. Repeat until it says END OF FILE, so the WHOLE file is indexed - never stop after the first window. (Do NOT call readFileContent on a PDF - see the next line.)
 - PDFs (scanned or not): you do NOT read a PDF with a tool or a URL. Its pages are RENDERED and embedded directly in the user message as IMAGE blocks, a WINDOW of pages at a time. LOOK at the embedded page images and datafy every one. The note beside them tells you whether MORE pages remain: if so, save this window's records and stop (a follow-up pass shows the next window automatically); only when the note says it was the LAST window is the PDF fully seen. Do NOT call readFileContent or web_fetch for a PDF.
 - VISION: when the message (a readFileContent window, an embedded PDF page, or an inline attachment) includes IMAGES - scanned/rendered PDF pages, or photos embedded in a spreadsheet next to a row/block - LOOK at them and capture what they show as record data (the reading/values in a scanned table, the part/defect/condition visible in a photo). The image IS part of the data; correlate each photo with its labelled block ("PHOTO A3" markers tie a photo to that grid row).
@@ -367,12 +386,16 @@ function buildIndexingSystemPrompt(params) {
 - Whatever the file type, this file's identity is "src::" + its storage path (the "storage path" metadata line) - never the inline content or a temporary URL. That record ALREADY EXISTS: the upload pipeline creates it in table "file_summaries" (access group "${accessGroup}") before indexing starts, so posting it again is rejected as a duplicate unique_id. Reference it from every record you write, and add what you learn to it with updateRecords. If that update unexpectedly reports the record does not exist, post it yourself ONCE with that exact "src::" unique_id (table "file_summaries", access group "${accessGroup}") and carry on; this is the ONE exception to the do-NOT-post-the-file-record rules elsewhere in these instructions, because the source identity must never be dropped just because an update failed.
 - ACCESS GROUP (hard rule): every record you write for this file - the file record, per-row records, chapters, summaries, intermediates - MUST be posted with access group "${accessGroup}". Pass it explicitly on every postRecords call; do not leave it out and do not vary it between passes of the same file. An access group is part of a record's table key, so records saved under a different group than the file are in a different table and will not come back with the rest of it: a "public" file whose rows were saved as "authorized" is one an anonymous visitor can see the name of and none of the contents of, and a re-index cannot find the strays to clean them up. The one exception is the EXTRACTED MEDIA records in "__MEDIA__", which the pipeline creates for you - leave their group alone and only enrich them.
 - REACHABILITY (hard rule): every record you write while indexing this file MUST be reachable from the file's "src::<storage path>" record by following reference - either reference that record directly, or reference something that already reaches it. A record with no reference, or one pointing outside this file's chain, is an ORPHAN: deleting or re-indexing the file removes the reachable records and leaves the orphan behind forever, where it keeps turning up in later answers as stale data. If you create an intermediate record that OTHER records reference (a page record that rows hang off, a sheet or section record), set source.can_remove_referencing_records to true on it; the delete cascade passes a delete through a record only when that record carries the flag OR a unique_id starting "src::" (the file record cascades because its unique_id starts with "src::"; the intermediates you create carry no "src::" id, so they need the flag), and it cascades ONE LEVEL AT A TIME, so EVERY intermediate record in a chain needs its own marker - an unmarked link stops the cascade there and everything below it survives as orphans. When in doubt, reference the file record directly and keep the chain flat.
-- TABULAR data (any spreadsheet - .csv/.tsv/.xlsx/.xls/.ods, or sheet-like rows): you MUST save EVERY data row as its own record (ONE record per row) with that row's actual column values in the record's "data", keyed by the header names, in a table named EXACTLY "spreadsheet_rows". Do NOT summarize, sample only a few rows, or save just file metadata - index the whole sheet, window by window, until it ends. Make MULTIPLE postRecords calls in batches (e.g. 30-50 rows per call) rather than one oversized call. This per-row completeness OVERRIDES brevity. The file-level "src::" record ALREADY EXISTS - the upload pipeline creates it before indexing starts - so do NOT create it. Link EVERY per-row record to it via reference (set each row record's reference to exactly "src::" + the storage path, with NO sheet/window/summary suffix added; the row records themselves do NOT carry a src:: unique_id). Enrich that same record with sheet name(s), column headers and total row count via updateRecords rather than posting another one. The per-row records AND this reference linkage are BOTH mandatory: the linkage is what lets the whole sheet be found and cleaned up together when the file is re-indexed. INDEX each row record on the row's most useful NUMERIC column (named by its header) so rows sort and range-query; when the row has no numeric column, index the grid row number instead. TAG each row record with the sheet name, the file name, and the row's categorical values (a status, a category, a type) - tags are how rows are filtered without scanning the table.
+- TABULAR data (any spreadsheet - .csv/.tsv/.xlsx/.xls/.ods, or sheet-like rows): UNLESS the message tells you the server has ALREADY saved this spreadsheet's rows as records (in which case you must NOT write row records and must NOT call readFileContent for it; your only job is the file-level summary it describes), you MUST save EVERY data row as its own record (ONE record per row) with that row's actual column values in the record's "data", keyed by the header names, in a table named EXACTLY "spreadsheet_rows". Do NOT summarize, sample only a few rows, or save just file metadata - index the whole sheet, window by window, until it ends. Make MULTIPLE postRecords calls in batches (e.g. 30-50 rows per call) rather than one oversized call. This per-row completeness OVERRIDES brevity. The file-level "src::" record ALREADY EXISTS - the upload pipeline creates it before indexing starts - so do NOT create it. Link EVERY per-row record to it via reference (set each row record's reference to exactly "src::" + the storage path, with NO sheet/window/summary suffix added; the row records themselves do NOT carry a src:: unique_id). Enrich that same record with sheet name(s), column headers and total row count via updateRecords rather than posting another one. The per-row records AND this reference linkage are BOTH mandatory: the linkage is what lets the whole sheet be found and cleaned up together when the file is re-indexed. INDEX each row record on the row's most useful NUMERIC column (named by its header) so rows sort and range-query; when the row has no numeric column, index the grid row number instead. TAG each row record with the sheet name, the file name, and the row's categorical values (a status, a category, a type) - tags are how rows are filtered without scanning the table.
+- WINDOW TAG. The message that shows you a window of a file names a tag of the form "win::" followed by a short code, and tells you to put it on every record you save from that window. Do it, on EVERY record, alongside the record's other tags. It is how the server removes exactly that window's records if the window ever has to be sent to you again, so that a retry never doubles what is stored. Never invent one, never reuse one from another window, and never leave it off.
 - ONE RECORD PER GRID ROW, ALWAYS. "Row" means the numbered row of the sheet (R37 is one record), never a visual block, item, section or left/right pair. Sheets that repeat the same columns side by side (an A/B block beside a C/D block, "paired" or "mirrored" layouts) still get ONE record per grid row, holding BOTH sides - suffix the keys to keep them apart (PART_NO_A / PART_NO_B). Collapsing a 16-row window into 2 or 3 "block" records is the single most damaging mistake here: it silently loses most of the cells and makes every later total wrong, because some windows were counted per row and others per block. If a window shows rows R37 to R52, you save records for R37..R52 and the count you report is the number of grid rows you actually wrote.
-- FIXED TABLE NAMES. Never invent a table name for one pass, and never vary the name between passes of the SAME file: that scatters one file's data across tables nobody can enumerate later, so the data is effectively lost even though every save succeeded. Use exactly "spreadsheet_rows" for spreadsheet row records, "book_chapters" for a chapter record, and "file_summaries" for the file-level record (which already exists, so update it and never post it). Embedded photos and other embedded files get NO table of your choosing: their records already exist in table "__MEDIA__", see EXTRACTED MEDIA below. For a content type none of those fit, choose ONE plain descriptive name, use that same name for every pass of the file, and never mint variants of it (inspection_items / item_records / sheet_items / inspection_data are four names for what is one table).
-- EXTRACTED MEDIA: every PICTURE embedded in an uploaded document (photos, diagrams, chart images) is pulled out and saved as a real permanent file under "__MEDIA__/<the document's storage path>/<name>", and a record for each one ALREADY EXISTS in table "__MEDIA__" with unique_id "src::<that path>", reference "src::<the document>", and its path, anchor and sheet already in data. Do NOT create it - the unique_id is taken and your post is rejected. UPDATE it with updateRecords, addressed by that unique_id, adding what the file actually SHOWS plus TAGS for every identifier visible in it (part numbers, tag ids, item names, serial numbers). An update REPLACES the fields you send, so send the existing tags back with your new ones and keep every field already in data (path, anchor, sheet, source, mime, bytes). ONE FILE, ONE RECORD: never also create a photo record in another table. If the update reports that the record does not exist, create it with that same unique_id, reference and data.path - the path must never be lost. Audio and video clips and non-picture attachments are NOT extracted, so never claim a separate file or a "__MEDIA__" record exists for one of those.
+- THE FILE NAME AND ITS FOLDERS ARE EVIDENCE ABOUT WHAT THE DATA MEANS, and often the only evidence there is. A grid of bare figures filed under "2026/Q2/royalties" is a quarterly royalty settlement; the same grid under "inspections/KCG-B507" is one aircraft's inspection. Nothing inside the sheet says so. Read the trail in the metadata block and use it: name the period, the entity, the counterparty or the subject in the file record's description, and TAG the records with the meaningful parts of it (the client, the aircraft, the quarter, the site), so a later question about that entity finds this file at all. A folder that is only an id or a date is still worth a tag; a folder like "uploads", "new" or "temp" is not.
+- BUT NEVER INSTEAD OF READING. The path tells you what the data is ABOUT; only the content tells you what it SAYS. Never infer a value, a column meaning, a row count or a total from a name, never let a name override what the cells actually contain, and never derive a TABLE name from a folder or a file name - table names are fixed (see below), and a table named after a folder scatters one kind of record across as many tables as the user has folders. Where the name and the content disagree, the content wins and the disagreement is worth recording.
+- FIXED TABLE NAMES. Never invent a table name for one pass, and never vary the name between passes of the SAME file: that scatters one file's data across tables nobody can enumerate later, so the data is effectively lost even though every save succeeded. Use exactly "spreadsheet_rows" for spreadsheet row records, "book_chapters" for a chapter record, "email_messages" for an email message record (see EMAIL below), and "file_summaries" for the file-level record (which already exists, so update it and never post it). Embedded photos and other embedded files get NO table of your choosing: their records already exist in table "__MEDIA__", see EXTRACTED MEDIA below. For a content type none of those fit, choose ONE plain descriptive name, use that same name for every pass of the file, and never mint variants of it (inspection_items / item_records / sheet_items / inspection_data are four names for what is one table).
+- EXTRACTED MEDIA: every PICTURE embedded in an uploaded document (photos, diagrams, chart images) is pulled out and saved as a real permanent file under "__MEDIA__/<the document's storage path>/<name>", and a record for each one ALREADY EXISTS in table "__MEDIA__" with unique_id "src::<that path>", reference "src::<the document>", and its path, anchor and sheet already in data. Do NOT create it - the unique_id is taken and your post is rejected. UPDATE it with updateRecords, addressed by that unique_id, adding what the file actually SHOWS plus TAGS for every identifier visible in it (part numbers, tag ids, item names, serial numbers). An update REPLACES the fields you send, so send the existing tags back with your new ones and keep every field already in data (path, anchor, sheet, source, mime, bytes). ONE FILE, ONE RECORD: never also create a photo record in another table. If the update reports that the record does not exist, create it with that same unique_id, reference and data.path - the path must never be lost. Audio and video clips and non-picture attachments are never saved as separate files (an email's attachment text is read inline instead, see EMAIL below), so never claim a separate file or a "__MEDIA__" record exists for one of those.
 - AUDIO files: transcribe the speech, and capture speakers (named where identifiable), the topics discussed, and timestamps of key moments in the record's data. TAG the language, the audio type (call, meeting, dictation, music), each speaker and every named entity; INDEX the duration in seconds as duration_seconds. VIDEO files: everything audio gets, PLUS transcribe on-screen text verbatim (same transcription discipline as photos) and capture the visual timeline - scene changes and what each scene shows, with timestamps. Same tags as audio plus every entity visible on screen, and INDEX duration_seconds here too. These audio and video rules apply to files UPLOADED AS FILES: the transcript and timeline land on the file's own "src::" record, which already exists. Audio or video embedded inside a document is NOT extracted, so never look for or promise a "__MEDIA__" record for it.
 - EPUB / e-books / long-form books (.epub or any book-length prose, provided inline in reading order with chapter headings preserved): you MUST save ONE record per CHAPTER (or, when chapters are unclear, per major section/topic) in the table "book_chapters" - never collapse the whole book into a single record. INDEX each chapter record on its chapter number (so chapters sort and range-query in order) and include the chapter title among its tags; the record's "data" must capture the chapter title plus its order/number AND a substantive summary of that chapter's content (key events, arguments, characters, places, concepts, terms, notable quotes). Apply AS MANY relevant tags as possible to EVERY chapter record (characters, locations, themes, topics, key concepts, key terms, dates, named entities) so the book is easy to SEARCH and cross-reference later - this is the whole point. ALSO put the book-level facts (title, author, language, overall summary, chapter list / table of contents, genre/subjects) onto the "src::" file record that ALREADY EXISTS in "file_summaries", using updateRecords. Do NOT post a second book-level record, and set every chapter record's reference to exactly "src::" + the storage path. This per-chapter completeness OVERRIDES brevity; human-readable summaries only, never raw/binary bytes.
+- EMAIL (.eml, provided inline with "=== EMAIL ===" / "=== BODY ===" / "=== ATTACHMENT i/N: ..." / "=== FORWARDED MESSAGE k (depth d) ===" headings, which always start at column 0; a body line that merely looks like one is body text): you MUST save ONE record per email MESSAGE in the table "email_messages", and a forwarded message inside it (its own "=== EMAIL ===" block) gets its OWN record. Each record carries subject, from, to, cc, date (the Date line: an ISO string when the layer could parse it, otherwise the raw header text), message_id, in_reply_to, and the body text (quoted earlier replies included). INDEX each record on its date as that string exactly as given, and include the sender address, every recipient address and the subject among its tags. Text under an "=== ATTACHMENT" heading is that attachment's extracted content: datafy it by its own kind (rows into "spreadsheet_rows" for a spreadsheet, one record per section for a document), tag those records with the attachment's filename, and give EVERY record the same "src::" reference as the email. Picture attachments are extracted into "__MEDIA__" like any other embedded picture (their media anchor is quoted on the "[picture ...]" line); other attachments are read inline: their content becomes the records above, but no separate FILE or file record exists for one, so never cite a path for it.
 - URL SOURCES: when the source being indexed is a URL rather than an uploaded file (a temporary or signed URL that merely DELIVERS an uploaded file's bytes is not a URL source; that file keeps its storage-path identity), its identity is "src::" + the FULL URL INCLUDING the query string (the query string often selects the content, so dropping it collapses different pages into one identity). If no record with that unique_id exists, create it; if the slot is already taken, update that record or reference it - never mint a variant id. For a WEB PAGE: extract everything on it, infer the page's primary entity type when it is not obvious (product, listing, article, profile), TAG that entity type plus the entities on the page, and INDEX the ONE number every entity of that type can be compared by (a price for a product, a date for an article). Any OTHER URL (a file behind a link) is downloaded and indexed under whichever per-type rule above matches its content. When the URL's content offers more index points than one record carries, add reference-linked records reachable from its "src::" record.
 - This is a background indexing task: do ALL the MCP saving FIRST, never reply mid-task, and never ask the user questions. Be exhaustive about meaning (and, for tabular data, about every row). SAVE AS YOU GO: persist each window's records before reading the next, so progress is never lost. If the file is so large you cannot finish in one turn, still save everything you have read so far; a follow-up pass will automatically continue from where you stopped. NEVER store raw or encoded file bytes in ANY field: no base64, no data: URIs, no hex or blob dumps. A long opaque non-human-readable string is not data - replace it with a structured description of what it encodes. If base64 or a data: URI is all you have for something, describe it conceptually and never paste it; if nothing human-readable can be extracted at all, OMIT that record rather than saving noise.
 - COMPLETION SIGNAL: only when YOU paged the file yourself with readFileContent and it reported "END OF FILE", with every row/item saved, end your final message with the token INDEXING_COMPLETE on its own line. If more rows remain, do NOT write that token - leaving it out is how the system knows to run another pass to continue. When the file arrives INSIDE this message one window at a time (an embedded window of rows/text, or rendered PDF page images), you are NOT the one who decides it is finished: the system advances the window off the real page/row count and sends the next pass automatically, so save this window, report what you saved, and never imply you have seen the whole file.
@@ -390,13 +413,21 @@ function indexingAccessGroup(attachment) {
   const g = attachment && attachment.accessGroup;
   return g === "public" || g === "private" ? g : "authorized";
 }
+function indexingFolderTrail(storagePath) {
+  if (typeof storagePath !== "string" || !storagePath) return "";
+  const parts = storagePath.split("/").filter(Boolean);
+  parts.pop();
+  return parts.join(" / ");
+}
 function buildIndexingUserMessage(attachment, options) {
   const head = `A new file has just been uploaded. Index it now.
 
 File metadata:
 - name: ${attachment.name}
 - storage path: ${attachment.storagePath}
-` + (attachment.mime ? `- mime type: ${attachment.mime}
+` + // Context, not an address. See indexingFolderTrail.
+  (indexingFolderTrail(attachment.storagePath) ? `- folders it was filed under: ${indexingFolderTrail(attachment.storagePath)}
+` : "") + (attachment.mime ? `- mime type: ${attachment.mime}
 ` : "") + (typeof attachment.size === "number" ? `- size (bytes): ${attachment.size}
 ` : "") + // Stated in the metadata block as well as the system prompt because this is
   // the per-FILE value: one project can hold public and private files at once,
@@ -449,7 +480,9 @@ function buildRenderMeta(attachment) {
   return `File metadata:
 - name: ${attachment.name}
 - storage path: ${attachment.storagePath}
-` + (attachment.mime ? `- mime type: ${attachment.mime}
+` + // Context, not an address. See indexingFolderTrail.
+  (indexingFolderTrail(attachment.storagePath) ? `- folders it was filed under: ${indexingFolderTrail(attachment.storagePath)}
+` : "") + (attachment.mime ? `- mime type: ${attachment.mime}
 ` : "") + `- access group (use this for EVERY record you write for this file): ${indexingAccessGroup(attachment)}
 `;
 }
@@ -493,7 +526,9 @@ function buildIndexingContinueMessage(attachment) {
 File metadata:
 - name: ${attachment.name}
 - storage path: ${attachment.storagePath}
-` + (attachment.mime ? `- mime type: ${attachment.mime}
+` + // Context, not an address. See indexingFolderTrail.
+  (indexingFolderTrail(attachment.storagePath) ? `- folders it was filed under: ${indexingFolderTrail(attachment.storagePath)}
+` : "") + (attachment.mime ? `- mime type: ${attachment.mime}
 ` : "") + `- access group (use this for EVERY record you write for this file): ${indexingAccessGroup(attachment)}
 
 Records for the earlier windows/pages of this file are ALREADY saved (they reference "${src}"). First call getRecords with reference "${src}" to see how far the previous pass got (the furthest row/window already saved). The reference ALONE is the whole query: it returns every record written from this file across ALL tables and ALL access groups, so do NOT add table_name or access_group to narrow it. The response is PAGED, so keep fetching pages until it reports there are no more, and take the furthest point from the WHOLE set, never from the first page. Then call readFileContent with the storage path above and a CURSOR that RESUMES just after that point - do NOT start at the beginning. The cursor is derivable from what you already saved:
@@ -524,7 +559,17 @@ var STATUS_MESSAGE = {
 function isTransientStatus(status) {
   return status === 408 || status === 425 || status === 429 || status >= 500;
 }
+function isCsrStatusEnvelope(res) {
+  return !!res && typeof res === "object" && !Array.isArray(res) && typeof res.status === "string" && typeof res.id === "string" && "in_queue" in res;
+}
+function csrEnvelopeError(input) {
+  if (!isCsrStatusEnvelope(input)) return void 0;
+  if (input.status !== "failed") return void 0;
+  return input.error != null ? input.error : { message: "The AI provider request failed." };
+}
 function getErrorMessage(input) {
+  var envErr = csrEnvelopeError(input);
+  if (envErr !== void 0) input = envErr;
   if (!input) return "Something went wrong.";
   if (typeof input === "string") return input;
   if (input.error && input.error.message) return input.error.message;
@@ -539,7 +584,9 @@ function getErrorMessage(input) {
   return "Something went wrong.";
 }
 function isErrorResponseBody(response) {
-  if (!response || typeof response !== "object") return false;
+  var envErr = csrEnvelopeError(response);
+  if (envErr !== void 0) response = envErr;
+  if (!response || typeof response !== "object") return envErr !== void 0;
   if (typeof response.status_code === "number" && response.status_code >= 400) return true;
   if (response.type === "error") return true;
   if (response.error && (response.error.message || response.error.type)) return true;
@@ -556,6 +603,8 @@ function isErrorResponseBody(response) {
   return false;
 }
 function isNonRetryableRequestError(input) {
+  var envErr = csrEnvelopeError(input);
+  if (envErr !== void 0) input = envErr;
   if (!input || typeof input !== "object") return false;
   var status = typeof input.status_code === "number" ? input.status_code : typeof input.status === "number" ? input.status : void 0;
   var param = void 0;
@@ -586,6 +635,8 @@ function isNonRetryableRequestError(input) {
   return false;
 }
 function isAuthExpiredError(input) {
+  var envErr = csrEnvelopeError(input);
+  if (envErr !== void 0) input = envErr;
   if (!input) return false;
   var blobs = [];
   var push = function(v) {
@@ -616,6 +667,8 @@ function isAuthExpiredError(input) {
   return hay.indexOf("token has expired") !== -1 || hay.indexOf("token is expired") !== -1 || hay.indexOf("expired_token") !== -1 || hay.indexOf("invalid_token") !== -1 || hay.indexOf("unauthorized") !== -1 || hay.indexOf("not authorized") !== -1 || hay.indexOf("invalid_request") !== -1 && hay.indexOf("token") !== -1;
 }
 function isProviderApiKeyError(input) {
+  var envErr = csrEnvelopeError(input);
+  if (envErr !== void 0) input = envErr;
   if (!input) return false;
   var blobs = [];
   var push = function(v) {
@@ -1066,6 +1119,7 @@ function getProjectContextWindow(projectId) {
   return key && projectContextWindows[key] ? projectContextWindows[key] : null;
 }
 var MAX_OUTPUT_TOKENS = 25e3;
+var INDEXING_MAX_OUTPUT_TOKENS = 64e3;
 var OUTPUT_TOKEN_RESERVE = MAX_OUTPUT_TOKENS;
 var TOOL_AND_RESPONSE_BUFFER = 4e3;
 var MIN_INPUT_TOKEN_BUDGET = 8e3;
@@ -1097,9 +1151,10 @@ function resolveByModelId(apiTable, staticTable, model) {
 function getModelContextWindow(platform, model) {
   return resolveByModelId(apiReportedContextWindows, CONTEXT_WINDOW_BY_MODEL, model) || CONTEXT_WINDOW_DEFAULT[platform];
 }
-function getMaxOutputTokens(platform, model) {
+function getMaxOutputTokens(platform, model, purpose) {
+  var want = purpose === "indexing" ? INDEXING_MAX_OUTPUT_TOKENS : MAX_OUTPUT_TOKENS;
   var cap = resolveByModelId(apiReportedMaxOutput, MAX_OUTPUT_BY_MODEL, model);
-  return cap ? Math.min(MAX_OUTPUT_TOKENS, cap) : MAX_OUTPUT_TOKENS;
+  return cap ? Math.min(want, cap) : want;
 }
 function getContextWindow(platform, model, projectId) {
   var ceiling = getModelContextWindow(platform, model);
@@ -1538,6 +1593,541 @@ function buildAiAgentValue(platform, model, contextWindow) {
   return p + "#" + m + "#" + Math.floor(n);
 }
 
+// src/engine/sse.ts
+var CLAUDE_EVENTS = {
+  message_start: true,
+  message_delta: true,
+  message_stop: true,
+  content_block_start: true,
+  content_block_delta: true,
+  content_block_stop: true,
+  ping: true
+};
+var CLAUDE_TOOL_BLOCKS = {
+  tool_use: true,
+  server_tool_use: true,
+  mcp_tool_use: true,
+  web_search_tool_use: true
+};
+var OPENAI_TOOL_ITEMS = {
+  function_call: true,
+  mcp_call: true,
+  web_search_call: true,
+  file_search_call: true,
+  code_interpreter_call: true,
+  computer_call: true,
+  image_generation_call: true
+};
+function detectProvider(type) {
+  if (!type) return null;
+  if (type.indexOf("response.") === 0) return "openai";
+  if (CLAUDE_EVENTS[type]) return "claude";
+  return null;
+}
+function lineEnd(s, from) {
+  for (var i = from; i < s.length; i++) {
+    var c = s.charCodeAt(i);
+    if (c === 10) return { at: i, len: 1 };
+    if (c === 13) {
+      if (i + 1 >= s.length) return null;
+      return { at: i, len: s.charCodeAt(i + 1) === 10 ? 2 : 1 };
+    }
+  }
+  return null;
+}
+function readFrame(lines) {
+  var event = "";
+  var data = [];
+  var framed = false;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    if (!line.length) continue;
+    if (line.charCodeAt(0) === 58) {
+      framed = true;
+      continue;
+    }
+    var colon = line.indexOf(":");
+    var field = colon === -1 ? line : line.slice(0, colon);
+    var value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.charCodeAt(0) === 32) value = value.slice(1);
+    if (field === "data") {
+      framed = true;
+      data.push(value);
+    } else if (field === "event") {
+      framed = true;
+      event = value;
+    } else if (field === "id" || field === "retry") {
+      framed = true;
+    }
+  }
+  return { event, data: data.join("\n"), framed };
+}
+function createSseParser() {
+  var buf = "";
+  var lines = [];
+  var lastSeq = 0;
+  var sawFraming = false;
+  var raw = "";
+  var rawHasContent = false;
+  var ended = false;
+  var rawParsed = false;
+  var rawBody = null;
+  var provider = null;
+  var terminalEvent = null;
+  var errored = false;
+  var error = null;
+  var stopReason = null;
+  var toolCalls = [];
+  var malformedFrames = 0;
+  var malformedToolJson = 0;
+  var message = null;
+  var blocks = /* @__PURE__ */ new Map();
+  var parts = /* @__PURE__ */ new Map();
+  var reasoning = /* @__PURE__ */ new Map();
+  var response = null;
+  var textCache = null;
+  var thinkingCache = null;
+  function feed(text) {
+    if (typeof text !== "string" || !text.length) return;
+    if (!sawFraming) {
+      raw += text;
+      if (!rawHasContent) rawHasContent = /\S/.test(text);
+      rawParsed = false;
+      rawBody = null;
+    }
+    buf += text;
+    var i = 0;
+    for (; ; ) {
+      var end2 = lineEnd(buf, i);
+      if (!end2) break;
+      var line = buf.slice(i, end2.at);
+      i = end2.at + end2.len;
+      if (line.length === 0) dispatch();
+      else lines.push(line);
+    }
+    if (i > 0) buf = buf.slice(i);
+  }
+  function feedChunks(chunks) {
+    if (!chunks || !chunks.length) return;
+    for (var i = 0; i < chunks.length; i++) {
+      var c = chunks[i];
+      if (!c || typeof c !== "object") continue;
+      var seq = typeof c.seq === "number" ? c.seq : 0;
+      if (seq && seq <= lastSeq) continue;
+      if (seq > lastSeq) lastSeq = seq;
+      feed(typeof c.txt === "string" ? c.txt : "");
+    }
+  }
+  function end() {
+    if (buf.length) {
+      var tail = buf.charCodeAt(buf.length - 1) === 13 ? buf.slice(0, -1) : buf;
+      if (tail.length) lines.push(tail);
+      buf = "";
+    }
+    if (lines.length) dispatch();
+    ended = true;
+  }
+  function isUnframed() {
+    return ended && !sawFraming && rawHasContent;
+  }
+  function dispatch() {
+    var pending = lines;
+    lines = [];
+    if (!pending.length) return;
+    try {
+      var frame = readFrame(pending);
+      if (frame.framed && !sawFraming) {
+        sawFraming = true;
+        raw = "";
+        rawHasContent = false;
+      }
+      if (!frame.data.length) return;
+      if (frame.data === "[DONE]") return;
+      var ev = JSON.parse(frame.data);
+      if (!ev || typeof ev !== "object") {
+        malformedFrames++;
+        return;
+      }
+      var type = typeof ev.type === "string" && ev.type ? ev.type : frame.event;
+      if (!type) {
+        malformedFrames++;
+        return;
+      }
+      if (!provider) provider = detectProvider(type);
+      if (provider === "openai") handleOpenAI(type, ev);
+      else if (provider === "claude") handleClaude(type, ev);
+      else handleUnattributed(type, ev);
+    } catch (e) {
+      malformedFrames++;
+    }
+  }
+  function handleUnattributed(type, ev) {
+    if (type === "error") {
+      takeError(ev && ev.error ? ev : { type: "error", error: ev });
+      return;
+    }
+    malformedFrames++;
+  }
+  function takeError(payload) {
+    errored = true;
+    terminalEvent = "error";
+    error = payload;
+  }
+  function handleClaude(type, ev) {
+    if (type === "ping") return;
+    if (type === "error") {
+      takeError({ type: "error", error: ev && ev.error ? ev.error : ev });
+      return;
+    }
+    if (type === "message_start") {
+      message = ev && ev.message ? shallowClone(ev.message) : { type: "message", role: "assistant" };
+      if (typeof message.stop_reason === "string") stopReason = message.stop_reason;
+      return;
+    }
+    if (type === "content_block_start") {
+      var idx = numberOr(ev.index, -1);
+      if (idx < 0) {
+        malformedFrames++;
+        return;
+      }
+      var block = ev.content_block ? shallowClone(ev.content_block) : {};
+      blocks.set(idx, { block, json: "", sawJson: false });
+      invalidate();
+      if (block && typeof block.type === "string" && CLAUDE_TOOL_BLOCKS[block.type]) {
+        var call = {
+          index: idx,
+          name: typeof block.name === "string" && block.name ? block.name : block.type,
+          type: block.type
+        };
+        if (typeof block.server_name === "string") call.serverName = block.server_name;
+        toolCalls.push(call);
+      }
+      return;
+    }
+    if (type === "content_block_delta") {
+      var i = numberOr(ev.index, -1);
+      var d = ev.delta;
+      if (i < 0 || !d || typeof d !== "object") {
+        malformedFrames++;
+        return;
+      }
+      var st = blocks.get(i);
+      if (!st) {
+        st = { block: { type: deltaBlockType(d.type) }, json: "", sawJson: false };
+        blocks.set(i, st);
+      }
+      applyClaudeDelta(st, d);
+      invalidate();
+      return;
+    }
+    if (type === "content_block_stop") {
+      var j = numberOr(ev.index, -1);
+      var s = j >= 0 ? blocks.get(j) : void 0;
+      if (s && s.sawJson) finishToolJson(s);
+      return;
+    }
+    if (type === "message_delta") {
+      if (!message) message = { type: "message", role: "assistant" };
+      var delta = ev.delta;
+      if (delta && typeof delta === "object") {
+        for (var k in delta) {
+          if (Object.prototype.hasOwnProperty.call(delta, k)) message[k] = delta[k];
+        }
+        if (typeof delta.stop_reason === "string") stopReason = delta.stop_reason;
+      }
+      if (ev.usage && typeof ev.usage === "object") {
+        message.usage = mergeInto(shallowClone(message.usage) || {}, ev.usage);
+      }
+      return;
+    }
+    if (type === "message_stop") {
+      terminalEvent = "message_stop";
+      return;
+    }
+    malformedFrames++;
+  }
+  function applyClaudeDelta(st, d) {
+    var t = d.type;
+    if (t === "text_delta") {
+      st.block.text = (st.block.text || "") + str(d.text);
+      return;
+    }
+    if (t === "thinking_delta") {
+      st.block.thinking = (st.block.thinking || "") + str(d.thinking);
+      return;
+    }
+    if (t === "signature_delta") {
+      st.block.signature = (st.block.signature || "") + str(d.signature);
+      return;
+    }
+    if (t === "input_json_delta") {
+      st.json += str(d.partial_json);
+      st.sawJson = true;
+      return;
+    }
+    if (t === "citations_delta") {
+      if (d.citation) {
+        if (!Array.isArray(st.block.citations)) st.block.citations = [];
+        st.block.citations.push(d.citation);
+      }
+      return;
+    }
+    malformedFrames++;
+  }
+  function finishToolJson(st) {
+    if (!st.json.length) {
+      return;
+    }
+    try {
+      st.block.input = JSON.parse(st.json);
+    } catch (e) {
+      malformedToolJson++;
+    }
+  }
+  function deltaBlockType(deltaType) {
+    if (deltaType === "thinking_delta" || deltaType === "signature_delta") return "thinking";
+    if (deltaType === "input_json_delta") return "tool_use";
+    return "text";
+  }
+  function handleOpenAI(type, ev) {
+    if (type === "response.output_text.delta") {
+      putPart(ev, str(ev.delta), false);
+      invalidate();
+      return;
+    }
+    if (type === "response.output_text.done") {
+      if (typeof ev.text === "string") {
+        putPart(ev, ev.text, true);
+        invalidate();
+      }
+      return;
+    }
+    if (type === "response.reasoning_summary_text.delta" || type === "response.reasoning_text.delta") {
+      putReasoning(type, ev, str(ev.delta), false);
+      invalidate();
+      return;
+    }
+    if (type === "response.reasoning_summary_text.done" || type === "response.reasoning_text.done") {
+      if (typeof ev.text === "string") {
+        putReasoning(type, ev, ev.text, true);
+        invalidate();
+      }
+      return;
+    }
+    if (type === "response.output_item.added") {
+      var item = ev.item;
+      if (item && typeof item.type === "string" && OPENAI_TOOL_ITEMS[item.type]) {
+        toolCalls.push({
+          index: numberOr(ev.output_index, toolCalls.length),
+          // A built-in tool (web_search_call) has no name of its own, so the item
+          // type is the only label there is and a row can still be drawn.
+          name: typeof item.name === "string" && item.name ? item.name : item.type,
+          type: item.type
+        });
+      }
+      return;
+    }
+    if (type === "response.completed" || type === "response.incomplete" || type === "response.failed") {
+      terminalEvent = type;
+      if (ev.response && typeof ev.response === "object") {
+        response = ev.response;
+        var st = response.status;
+        if (st === "incomplete") {
+          var reason = response.incomplete_details && response.incomplete_details.reason;
+          stopReason = typeof reason === "string" && reason ? reason : "incomplete";
+        } else if (typeof st === "string" && st) {
+          stopReason = st;
+        }
+        if (response.error && (response.error.message || response.error.code)) {
+          errored = true;
+          error = response;
+        }
+      }
+      if (type === "response.failed") errored = true;
+      return;
+    }
+    if (type === "response.error" || type === "error") {
+      takeError(ev && ev.error ? ev : { type: "error", error: ev });
+      return;
+    }
+  }
+  function putReasoning(type, ev, text, replace) {
+    var summary = type.indexOf("response.reasoning_summary_text.") === 0;
+    var oi = numberOr(ev.output_index, 0);
+    var idx = numberOr(summary ? ev.summary_index : ev.content_index, 0);
+    var key = oi + ":" + (summary ? "s" : "r") + ":" + idx;
+    var r = reasoning.get(key);
+    if (!r) {
+      r = { oi, idx, kind: summary ? 0 : 1, text: "" };
+      reasoning.set(key, r);
+    }
+    r.text = replace ? text : r.text + text;
+  }
+  function putPart(ev, text, replace) {
+    var oi = numberOr(ev.output_index, 0);
+    var ci = numberOr(ev.content_index, 0);
+    var key = oi + ":" + ci;
+    var p = parts.get(key);
+    if (!p) {
+      p = { oi, ci, text: "" };
+      parts.set(key, p);
+    }
+    p.text = replace ? text : p.text + text;
+  }
+  function invalidate() {
+    textCache = null;
+    thinkingCache = null;
+  }
+  function claudeTextBlocks() {
+    return orderedBlocks().filter(function(b) {
+      return b && b.type === "text";
+    });
+  }
+  function orderedBlocks() {
+    var idx = [];
+    blocks.forEach(function(_v, k) {
+      idx.push(k);
+    });
+    idx.sort(function(a, b) {
+      return a - b;
+    });
+    var out = [];
+    for (var i = 0; i < idx.length; i++) out.push(blocks.get(idx[i]).block);
+    return out;
+  }
+  function orderedParts() {
+    var out = [];
+    parts.forEach(function(p) {
+      out.push(p);
+    });
+    out.sort(function(a, b) {
+      return a.oi !== b.oi ? a.oi - b.oi : a.ci - b.ci;
+    });
+    return out;
+  }
+  function currentText() {
+    if (textCache !== null) return textCache;
+    var out;
+    if (provider === "openai") {
+      out = orderedParts().map(function(p) {
+        return p.text;
+      }).join("\n");
+    } else {
+      out = claudeTextBlocks().map(function(b) {
+        return b.text || "";
+      }).join("\n");
+    }
+    textCache = out;
+    return out;
+  }
+  function currentThinking() {
+    if (thinkingCache !== null) return thinkingCache;
+    var out;
+    if (provider === "openai") {
+      var rs = [];
+      reasoning.forEach(function(r) {
+        rs.push(r);
+      });
+      rs.sort(function(a, b) {
+        if (a.oi !== b.oi) return a.oi - b.oi;
+        if (a.idx !== b.idx) return a.idx - b.idx;
+        return a.kind - b.kind;
+      });
+      out = rs.map(function(r) {
+        return r.text;
+      }).join("\n");
+    } else {
+      out = orderedBlocks().filter(function(b) {
+        return b && b.type === "thinking";
+      }).map(function(b) {
+        return b.thinking || "";
+      }).join("\n");
+    }
+    thinkingCache = out;
+    return out;
+  }
+  function buildBody() {
+    if (provider === "openai") {
+      if (response) return response;
+    } else if (blocks.size || message) {
+      var base = message ? shallowClone(message) : { type: "message", role: "assistant" };
+      base.content = orderedBlocks();
+      return base;
+    }
+    if (errored && error) return error;
+    return unframedBody();
+  }
+  function unframedBody() {
+    if (!isUnframed()) return null;
+    if (rawParsed) return rawBody;
+    rawParsed = true;
+    try {
+      var v = JSON.parse(raw);
+      rawBody = v && typeof v === "object" ? v : null;
+    } catch (e) {
+      rawBody = null;
+    }
+    return rawBody;
+  }
+  function snapshot() {
+    return {
+      provider,
+      text: currentText(),
+      thinkingText: currentThinking(),
+      toolCalls: toolCalls.slice(),
+      toolNames: toolCalls.map(function(t) {
+        return t.name;
+      }),
+      stopReason,
+      complete: terminalEvent !== null,
+      // A terminal event that ENDED the answer rather than KILLED it. The
+      // `errored` term covers all three ways a stream dies with a terminal event
+      // on it: an Anthropic or OpenAI `error` frame (takeError sets both), a
+      // response.failed, and a response.completed/incomplete whose Response
+      // object carries an error payload. See the field's own doc for the loss
+      // this separation prevents.
+      answerComplete: terminalEvent !== null && terminalEvent !== "error" && !errored,
+      terminalEvent,
+      errored,
+      error,
+      malformedFrames,
+      malformedToolJson,
+      unframed: isUnframed(),
+      unframedText: isUnframed() ? raw : null,
+      lastSeq
+    };
+  }
+  return {
+    feed,
+    feedChunks,
+    end,
+    snapshot,
+    finalBody: buildBody
+  };
+}
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function numberOr(v, fallback) {
+  return typeof v === "number" && isFinite(v) ? v : fallback;
+}
+function shallowClone(o) {
+  if (!o || typeof o !== "object") return o;
+  var out = Array.isArray(o) ? o.slice() : {};
+  if (!Array.isArray(o)) {
+    for (var k in o) {
+      if (Object.prototype.hasOwnProperty.call(o, k)) out[k] = o[k];
+    }
+  }
+  return out;
+}
+function mergeInto(target, src) {
+  for (var k in src) {
+    if (Object.prototype.hasOwnProperty.call(src, k)) target[k] = src[k];
+  }
+  return target;
+}
+
 // src/engine/requests.ts
 var ANTHROPIC_MESSAGES_API_URL = "https://api.anthropic.com/v1/messages";
 var ANTHROPIC_MODELS_API_URL = "https://api.anthropic.com/v1/models";
@@ -1556,12 +2146,43 @@ var MCP_NAME = "BunnyQuery";
 var DEFAULT_CLAUDE_MODEL = "claude-sonnet-5";
 var DEFAULT_OPENAI_MODEL = "gpt-5.6-luna";
 var mcpUrl = () => chatEngineConfig().mcpBaseUrl;
+function withMcpParams(base, params) {
+  if (!base) return base;
+  const pairs = Object.keys(params).filter((k) => params[k] !== void 0 && params[k] !== null && params[k] !== "").map((k) => encodeURIComponent(k) + "=" + encodeURIComponent(String(params[k])));
+  if (!pairs.length) return base;
+  const [addr, existing] = base.split("?");
+  const hasPath = /^[a-z][a-z0-9+.-]*:\/\/[^/]+\/./i.test(addr);
+  const path = hasPath ? addr : addr.replace(/\/+$/, "") + "/";
+  return path + "?" + (existing ? existing + "&" : "") + pairs.join("&");
+}
+var mcpContextParam = (platform, model) => getModelContextWindow(platform, model);
+var mcpIndexingUrl = (platform = "openai", model) => withMcpParams(mcpUrl(), { profile: "index", ctx: mcpContextParam(platform, model) });
 function mcpEndpointFor(anonymous, publicProjectId, service) {
   if (!anonymous) return { url: mcpUrl(), token: "$ACCESS_TOKEN" };
   const project = publicProjectId || service;
   return { url: String(mcpUrl()).replace(/\/+$/, "") + "/p/" + project };
 }
 var clientSecretRequest = (opts) => chatEngineConfig().clientSecretRequest(opts);
+var CHAT_STREAM_ON = Object.freeze({
+  transport: Object.freeze({ stream: true }),
+  body: Object.freeze({ stream: true })
+});
+var CHAT_STREAM_OFF = Object.freeze({
+  transport: Object.freeze({}),
+  body: Object.freeze({})
+});
+var CHAT_STREAM_ON_REALTIME = Object.freeze({
+  // `realtime` rides on the TRANSPORT arm only. It is a skapi option, not a field
+  // the destination understands, so it must never reach `data`: the body arm stays
+  // exactly what it is with the socket off.
+  transport: Object.freeze({ stream: true, realtime: true }),
+  body: Object.freeze({ stream: true })
+});
+function chatStreamWiring(queue) {
+  if (!liveStreamingEnabled()) return CHAT_STREAM_OFF;
+  if (isBgIndexingQueue(queue)) return CHAT_STREAM_OFF;
+  return liveStreamingRealtimeEnabled() ? CHAT_STREAM_ON_REALTIME : CHAT_STREAM_ON;
+}
 var VARIANT_IMAGE_DETAIL = "original";
 var VARIANT_TEXT_VERBOSITY = "high";
 var OLDEST_NANO_REASONING_EFFORT = "high";
@@ -1708,6 +2329,7 @@ function applyHistoryCacheBreakpoint(messages) {
   });
 }
 var POLL_INTERVAL = 3e3;
+var STREAM_POLL_INTERVAL = 1e3;
 var MAX_CONCURRENT_BG_POLLS = 6;
 async function callClaudeWithMcp({
   prompt,
@@ -1730,12 +2352,14 @@ async function callClaudeWithMcp({
   if (mcpServer.authorizationToken) {
     mcpServerDefinition.authorization_token = mcpServer.authorizationToken;
   }
+  const stream = chatStreamWiring(userId || service);
   return clientSecretRequest({
     clientSecretName: "claude",
     queue: userId || service,
     service,
     owner,
     ...pollOpt(),
+    ...stream.transport,
     url: ANTHROPIC_MESSAGES_API_URL,
     method: "POST",
     headers: {
@@ -1747,6 +2371,9 @@ async function callClaudeWithMcp({
     data: {
       model,
       max_tokens: maxTokens,
+      // Top level beside model/messages/mcp_servers, which is where the
+      // Messages API takes it.
+      ...stream.body,
       ...extractContent && extractContent.length ? { _skapi_extract: extractContent } : {},
       ...fileUrls && fileUrls.length ? { _skapi_file_urls: fileUrls } : {},
       ...system ? {
@@ -1801,7 +2428,9 @@ async function callClaudeWithPublicMcp(prompt, service, owner, messages, system,
     fileUrls,
     mcpServer: {
       name: MCP_NAME,
-      url: endpoint.url,
+      url: withMcpParams(endpoint.url, {
+        ctx: mcpContextParam("claude", model || DEFAULT_CLAUDE_MODEL)
+      }),
       // Omitted entirely for an anonymous turn; the `if (mcpServer.authorizationToken)`
       // guard below drops the key rather than sending an empty one.
       authorizationToken: endpoint.token
@@ -1829,12 +2458,14 @@ async function callOpenAIWithPublicMcp(prompt, service, owner, messages, system,
       content: m.content
     }))
   ];
+  const stream = chatStreamWiring(userId || service);
   return clientSecretRequest({
     clientSecretName: "openai",
     queue: userId || service,
     service,
     owner,
     ...pollOpt(),
+    ...stream.transport,
     url: OPENAI_RESPONSES_API_URL,
     method: "POST",
     headers: {
@@ -1844,6 +2475,9 @@ async function callOpenAIWithPublicMcp(prompt, service, owner, messages, system,
     data: {
       model: resolvedModel,
       max_output_tokens: getMaxOutputTokens("openai", resolvedModel),
+      // Top level beside model/input/tools, which is where the Responses API
+      // takes it.
+      ...stream.body,
       ...extractContent && extractContent.length ? { _skapi_extract: extractContent } : {},
       ...fileUrls && fileUrls.length ? { _skapi_file_urls: fileUrls } : {},
       input: responseInput,
@@ -1851,7 +2485,7 @@ async function callOpenAIWithPublicMcp(prompt, service, owner, messages, system,
         {
           type: "mcp",
           server_label: MCP_NAME,
-          server_url: endpoint.url,
+          server_url: withMcpParams(endpoint.url, { ctx: mcpContextParam("openai", resolvedModel) }),
           require_approval: "never",
           // No `headers` at all for an anonymous turn: `Bearer ` with an
           // empty token is a credential the MCP server rejects, and the
@@ -1989,7 +2623,7 @@ async function notifyAgentSaveAttachment(info) {
       },
       data: {
         model: resolvedModel2,
-        max_output_tokens: getMaxOutputTokens("openai", resolvedModel2),
+        max_output_tokens: getMaxOutputTokens("openai", resolvedModel2, "indexing"),
         // Nano-only transcription knobs. Indexing only; see variantIndexingOptions.
         ...variantIndexingOptions(resolvedModel2),
         ...skapiExtract,
@@ -2007,7 +2641,7 @@ async function notifyAgentSaveAttachment(info) {
           {
             type: "mcp",
             server_label: MCP_NAME,
-            server_url: mcpUrl(),
+            server_url: mcpIndexingUrl("openai", resolvedModel2),
             require_approval: "never",
             headers: { Authorization: "Bearer $ACCESS_TOKEN" }
           },
@@ -2038,7 +2672,7 @@ async function notifyAgentSaveAttachment(info) {
     },
     data: {
       model: resolvedModel,
-      max_tokens: getMaxOutputTokens("claude", resolvedModel),
+      max_tokens: getMaxOutputTokens("claude", resolvedModel, "indexing"),
       ...skapiExtract,
       ...skapiRender,
       ...skapiWindow,
@@ -2060,7 +2694,7 @@ async function notifyAgentSaveAttachment(info) {
         {
           type: "url",
           name: MCP_NAME,
-          url: mcpUrl(),
+          url: mcpIndexingUrl("claude", resolvedModel),
           authorization_token: "$ACCESS_TOKEN"
         }
       ],
@@ -2257,9 +2891,9 @@ function probeBgQueue(params, opts) {
     { service: params.service, owner: params.owner, platform: params.platform, queue: params.queue, status: params.status },
     { limit: params.limit, fetchMore: false }
   )).then(function(result) {
-    const entry = { result, at: Date.now() };
-    bgProbeCache[key] = entry;
-    return entry;
+    const entry2 = { result, at: Date.now() };
+    bgProbeCache[key] = entry2;
+    return entry2;
   });
   bgProbeInflight[key] = p;
   p.then(function() {
@@ -2278,8 +2912,8 @@ async function fetchLiveIndexingKeys(params) {
   ]);
   const keys = /* @__PURE__ */ new Set();
   let truncated = false;
-  for (const entry of [pending, running]) {
-    const res = entry.result;
+  for (const entry2 of [pending, running]) {
+    const res = entry2.result;
     const list = res && Array.isArray(res.list) ? res.list : [];
     if (list.length >= LIVE_INDEX_PROBE_LIMIT) truncated = true;
     for (const item of list) {
@@ -2522,8 +3156,9 @@ function indexScopeKey(projectId, platform) {
   return projectId + "#" + platform;
 }
 function mapHistoryListToMessages(list, platform, opts) {
-  var mapped = [], runningItemIds = [];
+  var mapped = [], runningItemIds = [], streamPendingItemIds = [];
   var extractAssistantText = platform === "openai" ? extractOpenAIText : extractClaudeText;
+  var canRecoverStreams = streamRecoveryEnabled();
   var filtered = filterListByClearHorizon(list, opts.clearedAt);
   filtered.slice().reverse().forEach(function(item) {
     var requestBody = item && item.request_body;
@@ -2537,6 +3172,7 @@ function mapHistoryListToMessages(list, platform, opts) {
     var userText = isCompact ? typeof item.request_text === "string" ? item.request_text : "" : extractLastUserTextFromRequest(requestBody);
     var assistantText = isPending ? "" : isCompact ? (typeof item.response_text === "string" ? item.response_text : "").trim() : (extractAssistantText(response) || "").trim() || "";
     var isErrorResponse = !isPending && (isFailed || !isCompact && isErrorResponseBody(response));
+    var isStreamPending = canRecoverStreams && !isCompact && !isPending && !isCancelledItem && !isErrorResponse && !item._isBgTask && !item._isOnBgQueue && item.status === "resolved" && item.response_body == null && item.error == null && !assistantText;
     var reportedComplete = !!(item && item._isBgTask) && !isErrorResponse && (isCompact ? item.response_complete_marker === true : !!assistantText && assistantText.indexOf(INDEXING_COMPLETE_MARKER) !== -1);
     if (reportedComplete) assistantText = assistantText.split(INDEXING_COMPLETE_MARKER).join("").trim();
     var serverItemId = item && typeof item.id === "string" && item.id ? item.id : void 0;
@@ -2595,6 +3231,14 @@ function mapHistoryListToMessages(list, platform, opts) {
       if (serverItemId !== void 0) em._serverItemId = serverItemId;
       if (replyTs !== void 0) em._ts = replyTs;
       mapped.push(em);
+    } else if (isStreamPending) {
+      var sp = { role: "assistant", content: "", _streamPending: true };
+      if (serverItemId !== void 0) {
+        sp._serverItemId = serverItemId;
+        streamPendingItemIds.push(serverItemId);
+      }
+      if (replyTs !== void 0) sp._ts = replyTs;
+      mapped.push(sp);
     } else if (assistantText || reportedComplete) {
       var okm = { role: "assistant", content: sanitizeAttachmentLinksForHistory(assistantText, opts.projectId, true) || EMPTY_INDEXING_REPLY };
       if (item._fromBgChain) okm._fromBgChain = true;
@@ -2610,7 +3254,23 @@ function mapHistoryListToMessages(list, platform, opts) {
     var ownerKey = chatCacheKey(opts.projectId, platform, opts.userId);
     for (var oi = 0; oi < mapped.length; oi++) mapped[oi]._ownerKey = ownerKey;
   }
-  return { messages: mapped, runningItemIds };
+  return { messages: mapped, runningItemIds, streamPendingItemIds };
+}
+function adoptLocalAnswerIntoPage(incoming, local) {
+  if (!incoming || !local || !incoming._streamPending) return false;
+  if (incoming.role !== "assistant" || local.role !== "assistant") return false;
+  var hasText = typeof local.content === "string" && local.content.length > 0;
+  var isLive = !!(local.isPending || local._streaming);
+  if (!hasText && !isLive) return false;
+  if (hasText) {
+    incoming.content = local.content;
+    incoming._streamPending = false;
+  }
+  if (local._localId !== void 0) incoming._localId = local._localId;
+  if (local.isPending) incoming.isPending = true;
+  if (local.isPendingInProcess) incoming.isPendingInProcess = true;
+  if (local._streaming) incoming._streaming = true;
+  return true;
 }
 function shouldRescueInFlightMessage(m, ctx) {
   if (!m) return false;
@@ -2618,6 +3278,7 @@ function shouldRescueInFlightMessage(m, ctx) {
   if (m._ownerKey !== void 0 && ctx.loadKey !== void 0 && m._ownerKey !== ctx.loadKey) return false;
   if (m._serverItemId && ctx.hasServerId(m._serverItemId)) return false;
   if (m._stageId) return true;
+  if (m._streaming && !m._serverItemId) return true;
   if (!m._serverItemId && ctx.pageHasPendingAssistant) return false;
   if (m.isSendingToServer || m.isPendingQueued || m.isPendingInProcess || m.isPending) return true;
   if (ctx.sending && m.role === "user") {
@@ -3004,8 +3665,143 @@ function nextFrame(cb) {
 function isPollStopped(res) {
   return !!res && typeof res === "object" && res.status === "stopped";
 }
+var LIVE_PENDING_LINK_WINDOW = 512;
+var STREAM_RECOVERY_PER_LOAD = 2;
+function liveSafePrefix(text) {
+  if (!text) return "";
+  var cut = text.length;
+  var fenceAt = -1, fences = 0, from = 0, hit;
+  for (; ; ) {
+    hit = text.indexOf("```", from);
+    if (hit === -1) break;
+    fences++;
+    fenceAt = hit;
+    from = hit + 3;
+  }
+  if (fences % 2 === 1 && fenceAt !== -1) cut = fenceAt;
+  var head = text.slice(0, cut);
+  var lineStart = head.lastIndexOf("\n") + 1;
+  var line = head.slice(lineStart);
+  var open = line.lastIndexOf("[");
+  if (open !== -1 && line.length - open <= LIVE_PENDING_LINK_WINDOW) {
+    var rest = line.slice(open);
+    var close = rest.indexOf("]");
+    if (close === -1) {
+      cut = lineStart + open;
+    } else if (rest.charAt(close + 1) === "(" && rest.indexOf(")", close + 1) === -1) {
+      cut = lineStart + open;
+    }
+  }
+  var tokStart = line.length;
+  while (tokStart > 0 && !/\s/.test(line.charAt(tokStart - 1))) tokStart--;
+  var tok = line.slice(tokStart);
+  if (tok && /^(?:https?:\/\/|src::)/i.test(tok)) {
+    var tokCut = lineStart + tokStart;
+    if (tokCut < cut) cut = tokCut;
+  }
+  if (line.indexOf("```") === -1) {
+    var ticks = 0, lastTick = -1;
+    for (var i = 0; i < line.length; i++) {
+      if (line.charAt(i) === "`") {
+        ticks++;
+        lastTick = i;
+      }
+    }
+    if (ticks % 2 === 1 && lastTick !== -1) {
+      var tickCut = lineStart + lastTick;
+      if (tickCut < cut) cut = tickCut;
+    }
+  }
+  if (cut >= text.length) return text;
+  if (cut < 0) cut = 0;
+  return text.slice(0, cut);
+}
+function commonPrefixLength(a, b) {
+  var n = Math.min(a.length, b.length), i = 0;
+  while (i < n && a.charCodeAt(i) === b.charCodeAt(i)) i++;
+  if (i > 0) {
+    var prev = a.charCodeAt(i - 1);
+    if (prev >= 55296 && prev <= 56319) i--;
+  }
+  return i;
+}
+function typewriterResumeIndex(painted, fullText, regions) {
+  if (!painted || !fullText) return 0;
+  if (/^\s/.test(painted) && !/^\s/.test(fullText)) {
+    painted = painted.replace(/^\s+/, "");
+    if (!painted) return 0;
+  }
+  var i = commonPrefixLength(painted, fullText);
+  if (i <= 0) return 0;
+  if (i >= fullText.length) return fullText.length;
+  for (var changed = true; changed; ) {
+    changed = false;
+    for (var k = 0; k < regions.length; k++) {
+      var r = regions[k];
+      if (i > r.start && i < r.end) {
+        i = r.end;
+        changed = true;
+      }
+    }
+  }
+  return i > fullText.length ? fullText.length : i;
+}
+function mayKeepStreamedAnswer(snap, rowStatus) {
+  if (rowStatus !== void 0 && rowStatus !== null && rowStatus !== "" && rowStatus !== "resolved") return false;
+  if (!snap || typeof snap !== "object") return false;
+  if (snap.errored) return false;
+  if (snap.answerComplete) return true;
+  if (snap.unframed) return true;
+  return false;
+}
+function streamRecoveryPhase(msg) {
+  if (!msg || !msg._streamPending || msg.content || !msg._serverItemId) return "";
+  if (msg._streamRecovery === "active") return "active";
+  if (msg._streamRecovery === "failed") return "failed";
+  return "idle";
+}
+function streamRecoveryLabels(phase) {
+  if (phase === "failed") {
+    return { note: "Could not load this answer.", action: "Try again" };
+  }
+  return { note: "This answer was not saved with the conversation.", action: "Load answer" };
+}
+var LIVE_PAINT_MIN_MS = 250;
+var LIVE_TYPE_MAX_STEP = 1200;
 var ChatSession = class {
   constructor(host) {
+    // --- live streaming ----------------------------------------------------
+    //
+    // A streamed turn's answer NEVER reaches the polling row: the relay appends the
+    // destination's raw bytes to a chunk table and the row settles with a status and
+    // nothing else. So for a streamed turn this parser is not a nicety that makes the
+    // wait prettier, it is the only place the answer exists until csr-finalize stores
+    // one. Three things follow, and all three are load-bearing:
+    //
+    //   1. EVERY foreground poll gets a sink while streaming is on, not just the one
+    //      the dispatch attaches. A tab return, a reload, a resumePolling all
+    //      re-attach a poll to a still-running item, and skapi's reader sends
+    //      `since: 0` on its first tick, so a fresh sink REPLAYS the whole stream from
+    //      the beginning. Attaching without one settles that turn on an envelope and
+    //      the user's answer is gone.
+    //   2. The parser is keyed by SERVER ITEM ID, and so is the bubble it paints into.
+    //      A history refetch replaces the local pending bubble with the server's copy
+    //      of the same turn; that copy carries the same _serverItemId, so the next
+    //      paint finds it and carries on. Nothing has to be rescued and nothing can be
+    //      painted twice.
+    //   3. The stream is never the source of truth. At settle the parser's ASSEMBLED
+    //      body (byte equivalent to what a buffered call returns) goes through the
+    //      same extractClaudeText / extractOpenAIText the buffered path uses, and a
+    //      row that does hold a stored body wins outright.
+    //
+    // Background polls never get a sink, and that is safe because nothing on the bg
+    // queue ever streams: an indexing pass must not (the worker READS its reply), and
+    // a chat turn sent with attachments is deliberately left buffered for exactly the
+    // reason point 1 gives, since the re-attach loop would poll it as a background
+    // item and hand it no reader. See chatStreamWiring. A sink there would also spend
+    // the request budget MAX_CONCURRENT_BG_POLLS exists to protect.
+    /** Live streams by server item id. One per in-flight streamed turn. */
+    this.liveStreams = {};
     // ─── 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
@@ -3210,8 +4006,8 @@ var ChatSession = class {
       return Promise.resolve(probeBgQueue(
         { service: id.projectId, owner: id.owner, platform, queue, status, limit: WORKER_PASS_ADOPT_LIMIT },
         { maxAgeMs: BG_PROBE_TTL_MS }
-      )).then(function(entry) {
-        return entry.result;
+      )).then(function(entry2) {
+        return entry2.result;
       }).catch(function() {
         return null;
       });
@@ -3398,10 +4194,49 @@ var ChatSession = class {
    * and they are the ones bounded by MAX_CONCURRENT_BG_POLLS, so adding probes there would spend
    * the request budget the cap exists to protect.
    */
-  attachForegroundPoll(source, itemId, opts) {
-    return this._fgPollWithEarlyProbe(source, itemId, opts);
+  attachForegroundPoll(source, itemId, opts, ctx) {
+    return this._fgPollWithEarlyProbe(source, itemId, opts, ctx);
   }
-  _fgPollWithEarlyProbe(source, itemId, opts) {
+  _fgPollWithEarlyProbe(source, itemId, opts, ctx) {
+    var self = this;
+    var live = this._beginLiveStream(itemId, ctx);
+    if (live) {
+      var inner = opts || {};
+      var callerResponse = typeof inner.onResponse === "function" ? inner.onResponse : null;
+      var callerError = typeof inner.onError === "function" ? inner.onError : null;
+      var streamOpts = Object.assign({}, inner, {
+        onStream: function(chunk, _seq, via) {
+          self._feedLiveStream(live, chunk, via);
+        },
+        onResponse: function(res) {
+          var effective = res;
+          if (isPollStopped(res)) self._closeLiveStream(live, false);
+          else effective = self._settleLiveStream(live, res);
+          if (callerResponse) callerResponse(effective);
+        },
+        onError: function(err) {
+          self._closeLiveStream(live, false);
+          if (callerError) callerError(err);
+        }
+      });
+      var lp = source.poll(Object.assign({ latency: STREAM_POLL_INTERVAL }, streamOpts));
+      var stopLp = lp && typeof lp.stop === "function" ? lp.stop.bind(lp) : null;
+      var wrapped = Promise.resolve(lp).then(function(res) {
+        if (isPollStopped(res)) {
+          self._closeLiveStream(live, false);
+          return res;
+        }
+        return self._settleLiveStream(live, res);
+      }, function(err) {
+        self._closeLiveStream(live, false);
+        throw err;
+      });
+      wrapped.stop = function() {
+        self._closeLiveStream(live, false);
+        if (stopLp) stopLp();
+      };
+      return wrapped;
+    }
     var base = source.poll(Object.assign({ latency: POLL_INTERVAL }, opts || {}));
     var lookup = chatEngineConfig().csrHistoryItemLookup;
     var ident = this.host.getIdentity();
@@ -3483,6 +4318,661 @@ var ChatSession = class {
     });
     return n;
   }
+  /**
+   * Open (or re-open) the live stream for `itemId`, or null when this poll must
+   * not carry one.
+   *
+   * Re-entrant on purpose: an auth-refresh retry re-dispatches the SAME turn under
+   * a NEW id, and a re-attach after a tab return replays an existing id from seq 0.
+   * Either way the bytes about to arrive are a whole stream, so an existing entry
+   * is discarded and a fresh parser takes its place - feeding a replay into the old
+   * parser would concatenate the answer with itself.
+   *
+   * `ctx` IS THE TURN'S OWN IDENTITY, and every caller that has one passes it.
+   * This used to read the LIVE getIdentity(), which is a bug of exactly the kind
+   * _callProviderFor documents and threads its own parameters to avoid: the user
+   * hits Send, then switches project or platform inside the ack round trip, and the
+   * stream that opens for the OLD turn is stamped with the NEW identity. What that
+   * costs is not cosmetic - `platform` picks which url csr-finalize is addressed
+   * with and which extractor reads the assembled body, `projectId`/`owner` scope
+   * the finalize itself, and `ownerKey` decides which chat the answer is painted
+   * into. Get them from the live read at the wrong moment and the turn is finalized
+   * against the wrong service (so its answer is never stored), parsed with the
+   * wrong provider's extractor, or painted into a conversation it does not belong
+   * to. The live read stays only as the fallback for a caller with nothing pinned.
+   */
+  _beginLiveStream(itemId, ctx) {
+    if (!liveStreamingEnabled()) return null;
+    if (!itemId) {
+      console.warn("[chat-engine] live streaming is on but the dispatch reported no item id");
+      return null;
+    }
+    var pinnedPlatform = ctx && (ctx.platform === "claude" || ctx.platform === "openai") ? ctx.platform : void 0;
+    var ident = pinnedPlatform && ctx && ctx.projectId !== void 0 && ctx.owner !== void 0 && ctx.ownerKey !== void 0 ? null : this.host.getIdentity();
+    var platform = pinnedPlatform || (ident ? ident.platform : void 0);
+    if (platform !== "claude" && platform !== "openai") return null;
+    var projectId = ctx && ctx.projectId !== void 0 ? ctx.projectId : ident ? ident.projectId : "";
+    var owner = ctx && ctx.owner !== void 0 ? ctx.owner : ident ? ident.owner : "";
+    var ownerKey = ctx && ctx.ownerKey !== void 0 ? ctx.ownerKey : this.getHistoryCacheKey();
+    var prev = this.liveStreams[itemId];
+    if (prev) this._closeLiveStream(prev, false);
+    var st = {
+      id: itemId,
+      ownerKey,
+      platform,
+      projectId,
+      owner,
+      parser: createSseParser(),
+      painted: "",
+      started: false,
+      fed: false,
+      ended: false,
+      timer: null,
+      lastPaintAt: 0,
+      finalBody: null,
+      transport: { socket: 0, poll: 0 }
+    };
+    this.liveStreams[itemId] = st;
+    return st;
+  }
+  /** The chunk sink handed to skapi's poll. Raw relayed text, in order, never parsed
+   *  here: the parser owns the grammar and this owns the pacing. */
+  _feedLiveStream(st, chunk, via) {
+    if (st.ended || typeof chunk !== "string" || !chunk) return;
+    st.fed = true;
+    if (via === "socket") st.transport.socket++;
+    else if (via === "poll") st.transport.poll++;
+    st.parser.feed(chunk);
+    if (st.timer) return;
+    var self = this;
+    var wait = st.lastPaintAt ? Math.max(0, LIVE_PAINT_MIN_MS - (nowMs() - st.lastPaintAt)) : 0;
+    st.timer = setTimeout(function() {
+      st.timer = null;
+      self._paintLiveStream(st);
+    }, wait);
+  }
+  /**
+   * Write the safe prefix of the answer so far into the turn's bubble.
+   *
+   * notify() is spent EXACTLY ONCE per turn, on the first paint, because that is a
+   * state change the per-bubble refresh cannot express: the bubble stops being a
+   * "Thinking..." spinner and becomes text. Every paint after it goes through
+   * refreshMessageBubble, which is what keeps a growing answer from rebuilding the
+   * whole display list once a second.
+   */
+  _paintLiveStream(st) {
+    if (st.ended) return;
+    st.lastPaintAt = nowMs();
+    if (this.getHistoryCacheKey() !== st.ownerKey) return;
+    var idx = this._liveTargetIndex(st.id);
+    if (idx === -1) return;
+    var msg = this.state.messages[idx];
+    if (!msg) return;
+    var snap = st.parser.snapshot();
+    var next = liveSafePrefix(snap.text);
+    if (next.length <= st.painted.length) return;
+    var prev = st.painted;
+    st.painted = next;
+    var grew = next.length - prev.length;
+    var animate = grew > 0 && grew <= LIVE_TYPE_MAX_STEP;
+    if (animate) {
+      if (!msg._localId) msg._localId = this._newLocalId();
+      if (!msg._streaming) {
+        msg._streaming = true;
+        this.host.notify();
+      }
+      this.enqueueTypewrite(idx, next, msg._localId, prev);
+    } else {
+      msg.content = next;
+      if (!msg._streaming) {
+        msg._streaming = true;
+        this.host.notify();
+      } else this.host.refreshMessageBubble(idx);
+    }
+    this.host.scrollToBottomIfSticky();
+    this._reportLiveStream(st, st.started ? "update" : "start", snap, next);
+    st.started = true;
+  }
+  /** The bubble a live stream paints into: the turn's pending assistant placeholder,
+   *  found by server item id. Not by _localId, deliberately - a history refetch
+   *  replaces the local copy with the server's, and only the id survives that. */
+  _liveTargetIndex(itemId) {
+    return this.state.messages.findIndex(function(m) {
+      return !!m && m.role === "assistant" && !m.isBackgroundTask && m._serverItemId === itemId && (!!m.isPending || !!m._streaming);
+    });
+  }
+  /** Hand the host its optional observation update. Guarded: this runs on the paint
+   *  path, and a throwing hook must not cost the user the rest of their answer. */
+  _reportLiveStream(st, phase, snap, text) {
+    var hook = chatEngineConfig().onLiveStreamUpdate;
+    if (!hook) return;
+    try {
+      hook({
+        serverItemId: st.id,
+        ownerKey: st.ownerKey,
+        phase,
+        text,
+        thinkingText: snap && snap.thinkingText || "",
+        toolNames: snap && snap.toolNames ? snap.toolNames.slice() : [],
+        complete: !!(snap && snap.complete),
+        // Reported alongside `complete`, never instead of it: a host drawing
+        // "still arriving" wants complete, a host drawing "this answer is
+        // partial" wants this one, and an `error` frame is the case where the
+        // two disagree. See sse.ts answerComplete.
+        answerComplete: !!(snap && snap.answerComplete),
+        errored: !!(snap && snap.errored),
+        transport: { socket: st.transport.socket, poll: st.transport.poll }
+      });
+    } catch (e) {
+      console.warn("[chat-engine] onLiveStreamUpdate threw", e);
+    }
+  }
+  /** Stop painting and (when the turn really ended) assemble the body. `finished`
+   *  is false for a stream being discarded rather than settled: a retry replacing
+   *  it, or a stop, neither of which has an answer to assemble. */
+  _closeLiveStream(st, finished) {
+    var first = !st.ended;
+    if (st.timer) {
+      clearTimeout(st.timer);
+      st.timer = null;
+    }
+    if (first) {
+      st.ended = true;
+      if (finished && st.fed) {
+        st.parser.end();
+        st.finalBody = st.parser.finalBody();
+      }
+    }
+    if (this.liveStreams[st.id] === st) delete this.liveStreams[st.id];
+    if (first && st.started) this._reportLiveStream(st, "end", st.parser.snapshot(), "");
+    if (this.getHistoryCacheKey() !== st.ownerKey) return;
+    var idx = this._liveTargetIndex(st.id);
+    if (idx !== -1 && this.state.messages[idx] && this.state.messages[idx]._streaming) {
+      this.state.messages[idx]._streaming = false;
+    }
+  }
+  /**
+   * Settle a streamed turn: end the parse, decide the body the rest of the session
+   * will read, and release the chunks.
+   *
+   * The substitution is one-directional and never a merge. A response that is a
+   * real stored body (a buffered turn, or a streamed one somebody already
+   * finalized) is returned untouched, because that is the destination's own answer
+   * and the stream is not entitled to overwrite it. Only a STATUS ENVELOPE - the
+   * shape a streamed row settles as, having stored nothing - is replaced, and then
+   * by the assembled body, which every caller downstream reads with the same
+   * extractor it uses for a buffered reply. Idempotent, because it is reached both
+   * through the poll's onResponse and through the promise it resolves.
+   */
+  _settleLiveStream(st, response) {
+    this._closeLiveStream(st, true);
+    if (!isCsrStatusEnvelope(response)) return response;
+    if (response.status !== "resolved") return response;
+    if (!this._mayFinalize(st)) this._rec().incomplete[st.id] = true;
+    if (st.finalBody == null) return response;
+    this._finalizeStreamedTurn(st);
+    return st.finalBody;
+  }
+  /**
+   * May this parse be STORED as the turn's permanent answer?
+   *
+   * THE FAILURE THIS PREVENTS. Finalizing does two things at once: it stores what
+   * you give it as the row's result, and it DELETES the chunks it was assembled
+   * from. So finalizing a truncated parse is not a cosmetic loss, it is the
+   * permanent one: the truncation becomes the stored answer and the only copy of
+   * the missing part is deleted in the same call. And a truncated parse is a shape
+   * this repo has already paid for - a degraded chunk read (the poller degrades to
+   * "no chunks this tick, more=true" on any transient chunk-table error, and caps
+   * a long answer at 500k characters per response) can hand the settle a stream
+   * that stopped mid-answer. The row can settle 'resolved' on top of that, because
+   * the ROW's status describes the destination's request, not the client's read of
+   * it.
+   *
+   * THE POLICY ITSELF IS mayKeepStreamedAnswer (top of this file), shared with the
+   * recovery path so the two cannot drift apart again - they did, and the drift was
+   * silent: the live settle refused a failed turn while the recovery finalized one.
+   * What is local to this method is only the two things the free function cannot
+   * know: that there is an assembled body at all, and that this call site is
+   * reached only on a row that settled 'resolved' (the caller returns before it
+   * otherwise), which is the status it therefore states.
+   *
+   * The test the policy applies is deliberately NOT `complete`: a terminal event
+   * arrived and the answer finished are two claims, and an `error` frame satisfies
+   * the first while truncating the second. See sse.ts's answerComplete.
+   */
+  _mayFinalize(st) {
+    if (st.finalBody == null) return false;
+    return mayKeepStreamedAnswer(st.parser.snapshot(), "resolved");
+  }
+  /**
+   * Store the assembled body as the version history keeps, which is also what
+   * releases this request's chunks.
+   *
+   * The ASSEMBLED BODY and not the extracted text, because the row is read back by
+   * mapHistoryListToMessages through extractClaudeText / extractOpenAIText: storing
+   * the provider's own document is what makes a streamed turn indistinguishable
+   * from a buffered one on the next load, with no branch anywhere in the mapper.
+   *
+   * BEST EFFORT, and loudly so: the answer is already on screen and already in the
+   * history cache by the time this fires. A failure costs the chunks (they stay,
+   * and the turn stays re-readable) and a row that reads back empty, never the
+   * user's answer in front of them.
+   *
+   * WHAT IS DELIBERATELY NEVER FINALIZED, because finalize is also the only way to
+   * release chunks and it is tempting to reach for it as a cleanup:
+   *
+   *   - an INCOMPLETE parse (see _mayFinalize). Storing a truncation makes it
+   *     permanent AND deletes the part that was missing from it. A stream killed by
+   *     an `error` frame is one of these however terminal it looks: the frame ends
+   *     the stream, so `complete` is true, while the text is only what arrived
+   *     before the error. That is why the gate reads answerComplete.
+   *   - a FAILED turn. Its chunks hold the part of the answer that did arrive,
+   *     which is the only copy of that text there is, and the two ways to release
+   *     them both cost something real: storing the partial makes a truncated answer
+   *     the turn's permanent history AND masks the failure on read (csr-poll hands
+   *     back a finalized body before it ever looks at the row's error, so the turn
+   *     would read back as a clean short answer), while storing the error throws
+   *     the partial away outright. Keeping them costs storage on rows that produced
+   *     bytes and then failed, which is rare - a failure before the first byte (a
+   *     wrong API key, the common case) has no chunks to keep - and the poller
+   *     hands those chunks back alongside the error on every later read, so nothing
+   *     is stranded, only retained. Retention is the honest trade here; deletion is
+   *     not reversible.
+   *   - a CANCELLED turn, for the same reason plus one: the user's Stop means the
+   *     half answer is to be discarded, so writing it into history as the kept
+   *     version would resurrect exactly what the stop was for.
+   */
+  _finalizeStreamedTurn(st) {
+    if (st.finalized) return;
+    if (!this._mayFinalize(st)) return;
+    var fin = chatEngineConfig().clientSecretRequestFinalize;
+    if (!fin || st.finalBody == null) return;
+    st.finalized = true;
+    var url = st.platform === "openai" ? OPENAI_RESPONSES_API_URL : ANTHROPIC_MESSAGES_API_URL;
+    try {
+      Promise.resolve(fin(st.id, st.finalBody, {
+        url,
+        method: "POST",
+        service: st.projectId,
+        owner: st.owner
+      })).catch(function(err) {
+        console.warn("[chat-engine] clientSecretRequestFinalize failed", err);
+      });
+    } catch (e) {
+      console.warn("[chat-engine] clientSecretRequestFinalize threw", e);
+    }
+  }
+  /** Painted-but-unsettled live text on a bubble, for the typewriter to resume from.
+   *  A pending assistant placeholder is created with content '' by every path that
+   *  makes one, so non-empty content on one can only have been painted here. */
+  _paintedTextAt(idx) {
+    var m = idx >= 0 ? this.state.messages[idx] : void 0;
+    if (!m || m.role !== "assistant" || typeof m.content !== "string") return "";
+    return m.content;
+  }
+  /** The recovery bookkeeping, created on first touch.
+   *
+   *  LAZY, not constructor-initialised, and for a concrete reason: ChatSession is
+   *  also built with Object.create(ChatSession.prototype) by the engine's own test
+   *  harnesses, which drive one method against a hand-built state rather than a
+   *  whole session. A field only the constructor creates is undefined there, and
+   *  the method that reaches for it throws, turning a test of the settle into a
+   *  crash about bookkeeping. */
+  _rec() {
+    if (!this._streamRecovery) this._streamRecovery = { incomplete: {}, attempted: {}, inflight: {}, failed: {}, queue: [], running: false };
+    return this._streamRecovery;
+  }
+  /**
+   * Put this session's fetching state onto the turn's bubble, so a view can tell a
+   * loader that means something from one that means nothing.
+   *
+   * ONLY EVER ONTO A STILL-MARKED BUBBLE. Once `_streamPending` is off the turn has
+   * an answer (or was proven to have none) and this says nothing about it; writing
+   * it there would leave a stale 'active' on a settled bubble forever.
+   *
+   * host.notify() is what redraws the widget, whose renderer is imperative. It is a
+   * no-op in agent.vue, whose state is a Vue reactive() - the property write above
+   * is what redraws there. Both are covered by doing both, and neither is a
+   * substitute for the other.
+   */
+  _markRecoveryPhase(itemId, phase) {
+    var changed = false;
+    for (var i = 0; i < this.state.messages.length; i++) {
+      var m = this.state.messages[i];
+      if (!m || m.role !== "assistant" || m._serverItemId !== itemId || !m._streamPending) continue;
+      var next = phase === null ? void 0 : phase;
+      if (m._streamRecovery === next) continue;
+      if (next === void 0) delete m._streamRecovery;
+      else m._streamRecovery = next;
+      changed = true;
+    }
+    if (changed) this.host.notify();
+  }
+  /**
+   * Let LOCAL answers survive a freshly-mapped page whose copies of them are
+   * authoritative-but-empty. Call with the page BEFORE it replaces or merges into
+   * state.messages; mutates the page's bubbles in place.
+   *
+   * The adoption itself is history.ts's adoptLocalAnswerIntoPage (shared, so the
+   * clients' own mappers cannot fork it). What lives here is the one thing the
+   * pure function cannot know: whether the local text is the WHOLE answer. Text
+   * left by a stream that ended without a terminal event is not, so that bubble
+   * keeps its marker and gets read back even though it has content - otherwise a
+   * truncated answer would adopt itself over the row and never be corrected.
+   */
+  _adoptLocalAnswers(mapped, loadKey) {
+    if (!mapped || !mapped.length) return;
+    var pendingIncoming = [];
+    for (var i = 0; i < mapped.length; i++) {
+      if (mapped[i] && mapped[i]._streamPending) pendingIncoming.push(mapped[i]);
+    }
+    if (!pendingIncoming.length) return;
+    var locals = {};
+    for (var j = 0; j < this.state.messages.length; j++) {
+      var lm = this.state.messages[j];
+      if (!lm || lm.role !== "assistant" || !lm._serverItemId) continue;
+      if (lm._ownerKey !== void 0 && loadKey !== void 0 && lm._ownerKey !== loadKey) continue;
+      if (locals[lm._serverItemId] === void 0) locals[lm._serverItemId] = lm;
+    }
+    for (var k = 0; k < pendingIncoming.length; k++) {
+      var inc = pendingIncoming[k];
+      var id = inc._serverItemId;
+      if (!id) continue;
+      var local = locals[id];
+      if (!local) continue;
+      if (!adoptLocalAnswerIntoPage(inc, local)) continue;
+      if (this._rec().incomplete[id]) inc._streamPending = true;
+    }
+    for (var p = 0; p < pendingIncoming.length; p++) {
+      var pi = pendingIncoming[p];
+      if (!pi._streamPending || !pi._serverItemId) continue;
+      var phase = this._recoveryPhaseFor(pi._serverItemId);
+      if (phase === null) delete pi._streamRecovery;
+      else pi._streamRecovery = phase;
+    }
+  }
+  /**
+   * This session's fetching state for one turn, from the bookkeeping rather than
+   * from any bubble. A queued entry counts as 'active': it is committed to be read,
+   * serially, and the reader has no way to tell "being read" from "next in line"
+   * apart from the wait.
+   */
+  _recoveryPhaseFor(itemId) {
+    var rec = this._rec();
+    if (rec.inflight[itemId]) return "active";
+    for (var i = 0; i < rec.queue.length; i++) if (rec.queue[i].id === itemId) return "active";
+    if (rec.failed[itemId]) return "failed";
+    return null;
+  }
+  /**
+   * PUBLIC DELEGATE, for a client that maps and merges its own history page.
+   *
+   * agent.vue keeps a forked mapper and a forked first-page merge (its mount path
+   * runs them, while resumePolling routes through loadHistory below), so both
+   * paths are live for the SAME row inside one component. Adoption is part of the
+   * merge contract, not an optional extra: without it that fork erases a streamed
+   * answer off the screen on every turn, which is the whole of MAJOR 3.
+   *
+   * Exposed rather than reimplemented because the rule needs the session's own
+   * `incomplete` set, which the pure helper (history.ts adoptLocalAnswerIntoPage)
+   * cannot see. A client that reached for the helper alone would adopt a TRUNCATED
+   * answer over the row and clear the marker that would have gone back for the
+   * rest - a fork that reads as correct and loses text.
+   *
+   * Call it exactly where loadHistory does: on the freshly mapped page, after
+   * applyHydratedBodies and BEFORE the page replaces or merges into state.messages.
+   */
+  adoptLocalAnswers(mapped, loadKey) {
+    this._adoptLocalAnswers(mapped, loadKey);
+  }
+  /**
+   * Queue the on-screen turns whose answer is only in the chunk store, newest
+   * first, and start draining. Never blocks and never throws.
+   *
+   * `ownerKey` is the chat the queue entries belong to, snapshotted by the caller:
+   * a recovery that lands after the user has moved on writes into that chat's
+   * cache, never into whatever list is on screen by then.
+   */
+  _scheduleStreamRecovery(ownerKey, platform, projectId, owner) {
+    if (!streamRecoveryEnabled()) return;
+    var rec = this._rec();
+    var wanted = [];
+    for (var i = this.state.messages.length - 1; i >= 0; i--) {
+      var m = this.state.messages[i];
+      if (!m || m.role !== "assistant" || !m._streamPending || !m._serverItemId) continue;
+      var id = m._serverItemId;
+      if (rec.attempted[id]) continue;
+      if (this.liveStreams[id]) continue;
+      if (rec.queue.some(function(e) {
+        return e.id === id;
+      })) continue;
+      wanted.push(id);
+      if (wanted.length >= STREAM_RECOVERY_PER_LOAD) break;
+    }
+    if (!wanted.length) return;
+    for (var w = 0; w < wanted.length; w++) {
+      rec.queue.push({ id: wanted[w], ownerKey, platform, projectId, owner });
+      this._markRecoveryPhase(wanted[w], "active");
+    }
+    this._drainStreamRecovery();
+  }
+  /**
+   * PUBLIC DELEGATE, the other half of what a forked history path needs.
+   *
+   * Same reason as adoptLocalAnswers: agent.vue's mount path never calls
+   * loadHistory, so without this its pages would MARK unfinalized streamed turns
+   * and then never read them back - CRITICAL 1 left unfixed on the client's
+   * primary path, with the marker making it look handled.
+   *
+   * Takes the load's SNAPSHOTTED identity rather than reading it live, and that is
+   * the reason this exists instead of the caller looping over recoverStreamedAnswer:
+   * that one reads getIdentity() at call time (right, for an on-demand affordance
+   * the user just clicked), which after a project switch racing the load would
+   * finalize the turn against the project they switched TO. Call it AFTER the page
+   * is rendered and the loading flags are cleared - it must never hold up the
+   * conversation it belongs to.
+   */
+  scheduleStreamRecovery(ownerKey, platform, projectId, owner) {
+    this._scheduleStreamRecovery(ownerKey, platform, projectId, owner);
+  }
+  /** Serial drain of the recovery queue. Each entry is one full chunk read. */
+  _drainStreamRecovery() {
+    var rec = this._rec();
+    if (rec.running) return;
+    var next = rec.queue.shift();
+    if (!next) return;
+    rec.running = true;
+    var self = this;
+    this._readBackStreamedTurn(next.id, next.ownerKey, next.platform, next.projectId, next.owner).catch(function() {
+    }).then(function() {
+      self._rec().running = false;
+      self._drainStreamRecovery();
+    });
+  }
+  /**
+   * Read one unfinalized streamed turn back out of the chunk store and put its
+   * answer where the turn's answer belongs.
+   *
+   * Public because the cap above is deliberately small: a host that wants to offer
+   * "load the rest" on an older recoverable turn calls this with its
+   * `_serverItemId`, and gets the same path the automatic recovery uses. Safe to
+   * call for an id that turns out not to be recoverable, and safe to call twice -
+   * a second call while the first is still in flight is a no-op.
+   *
+   * THIS IS THE USER ASKING, and that is why it passes `manual`. The automatic
+   * recovery refuses a row it has already tried, so that a re-render, or the
+   * history load that every visibilitychange fires, cannot loop on the same
+   * chunks. A click is neither of those: it is one bounded request that a person
+   * asked for, and applying the loop guard to it made the affordance a button that
+   * silently did nothing for exactly the rows most likely to have it - every row
+   * an earlier read touched and could not settle.
+   */
+  recoverStreamedAnswer(itemId) {
+    if (!itemId) return Promise.resolve();
+    var id = this.host.getIdentity();
+    var platform = id && id.platform === "openai" ? "openai" : "claude";
+    return this._readBackStreamedTurn(itemId, this.getHistoryCacheKey(), platform, id ? id.projectId : "", id ? id.owner : "", true);
+  }
+  _readBackStreamedTurn(itemId, ownerKey, platform, projectId, owner, manual) {
+    var cfg = chatEngineConfig();
+    var read = cfg.clientSecretRequestStream;
+    if (!read || !itemId) return Promise.resolve();
+    if (this._rec().inflight[itemId]) return Promise.resolve();
+    if (!manual && this._rec().attempted[itemId]) {
+      this._markRecoveryPhase(itemId, null);
+      return Promise.resolve();
+    }
+    this._rec().attempted[itemId] = true;
+    this._rec().inflight[itemId] = true;
+    delete this._rec().failed[itemId];
+    this._markRecoveryPhase(itemId, "active");
+    var self = this;
+    var url = platform === "openai" ? OPENAI_RESPONSES_API_URL : ANTHROPIC_MESSAGES_API_URL;
+    var parser = createSseParser();
+    var fed = false;
+    return Promise.resolve(read(itemId, {
+      url,
+      method: "POST",
+      service: projectId,
+      owner,
+      since: 0,
+      onStream: function(chunk) {
+        if (typeof chunk !== "string" || !chunk) return;
+        fed = true;
+        parser.feed(chunk);
+      }
+    })).then(function(res) {
+      if (isPollStopped(res)) {
+        delete self._rec().attempted[itemId];
+        delete self._rec().inflight[itemId];
+        self._markRecoveryPhase(itemId, null);
+        return;
+      }
+      var envelope = isCsrStatusEnvelope(res);
+      var body = null;
+      if (res && !envelope) {
+        body = res;
+      } else if (fed) {
+        parser.end();
+        body = parser.finalBody();
+      }
+      var snap = parser.snapshot();
+      var fromRow = !!(res && !envelope);
+      var rowStatus = envelope && typeof res.status === "string" ? res.status : void 0;
+      var degraded = !!(envelope && res && res.more === true);
+      var store = !fromRow && !degraded && body != null && mayKeepStreamedAnswer(snap, rowStatus);
+      delete self._rec().inflight[itemId];
+      delete self._rec().failed[itemId];
+      self._markRecoveryPhase(itemId, null);
+      if (degraded) {
+        delete self._rec().attempted[itemId];
+      }
+      self._applyRecoveredAnswer(itemId, ownerKey, platform, projectId, owner, body, store, degraded);
+    }, function(err) {
+      console.warn("[chat-engine] could not read back a streamed turn", itemId, err);
+      delete self._rec().attempted[itemId];
+      delete self._rec().inflight[itemId];
+      self._rec().failed[itemId] = true;
+      self._markRecoveryPhase(itemId, "failed");
+    });
+  }
+  /**
+   * Write a recovered answer into the turn's bubble (or into the owning chat's
+   * cache when the reader has moved on), then store it as the version history
+   * keeps.
+   *
+   * FINALIZING IS WHAT MAKES THIS RUN ONCE. It copies the answer onto the row and
+   * releases the chunks, so the next load reads an ordinary turn and no recovery is
+   * scheduled for it ever again, by anyone, in any tab. `store` is the caller's
+   * decision and carries two gates at once: mayKeepStreamedAnswer, the SAME keep
+   * policy the live settle applies (an incomplete, errored or failed read is shown
+   * but never stored, because storing it would make the truncation permanent and
+   * delete the part that was missing), and whether the body is new at all (one
+   * that came off the row is already stored).
+   */
+  _applyRecoveredAnswer(itemId, ownerKey, platform, projectId, owner, body, store, degraded) {
+    var text = "";
+    var isErr = isErrorResponseBody(body);
+    if (body != null && !isErr) {
+      text = ((platform === "openai" ? extractOpenAIText(body) : extractClaudeText(body)) || "").trim();
+    }
+    if (!text && !isErr) {
+      if (degraded) {
+        return;
+      }
+      this._clearStreamPendingMark(itemId, ownerKey, true);
+      return;
+    }
+    var reply = isErr ? { role: "assistant", content: getErrorMessage(body), isError: true, _serverItemId: itemId } : { role: "assistant", content: text, _serverItemId: itemId };
+    if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
+      this._applyReplyToCache(ownerKey, reply, itemId);
+    } else {
+      var idx = -1;
+      for (var i = 0; i < this.state.messages.length; i++) {
+        var m = this.state.messages[i];
+        if (m && m.role === "assistant" && m._serverItemId === itemId) {
+          idx = i;
+          break;
+        }
+      }
+      if (idx === -1) {
+        this._applyReplyToCache(ownerKey, reply, itemId);
+      } else {
+        var prev = this.state.messages[idx];
+        if (prev._ts !== void 0) reply._ts = prev._ts;
+        if (prev._ownerKey !== void 0) reply._ownerKey = prev._ownerKey;
+        this.state.messages[idx] = reply;
+        this.updateHistoryCache();
+        this.host.notify();
+      }
+    }
+    if (!degraded) delete this._rec().incomplete[itemId];
+    if (!store || body == null || isErr) return;
+    var fin = chatEngineConfig().clientSecretRequestFinalize;
+    if (!fin) return;
+    var url = platform === "openai" ? OPENAI_RESPONSES_API_URL : ANTHROPIC_MESSAGES_API_URL;
+    try {
+      Promise.resolve(fin(itemId, body, { url, method: "POST", service: projectId, owner })).catch(function(err) {
+        console.warn("[chat-engine] finalize of a recovered turn failed", err);
+      });
+    } catch (e) {
+      console.warn("[chat-engine] finalize of a recovered turn threw", e);
+    }
+  }
+  /**
+   * Take the "answer is elsewhere" marker off a turn once it is settled one way or
+   * the other. `drop` removes an assistant bubble that turned out to have no answer
+   * at all, which restores exactly the list the mapper used to produce for such a
+   * row (none), rather than leaving a permanently empty bubble behind.
+   *
+   * ONLY EVER CALLED FOR A TURN THAT WAS ACTUALLY READ. The marker is the one thing
+   * that keeps an unrecovered answer reachable, so it comes off only on the strength
+   * of an answer (the recovery wrote one) or of a read that came back empty. A read
+   * that FAILED, or one that was STOPPED, knows neither, and taking the marker off
+   * on either of those is how a bubble ends up empty forever with its answer still
+   * in the chunk table. `drop` is likewise never passed for a bubble that HAS
+   * content: an empty row is an empty turn, a failed read is not.
+   */
+  _clearStreamPendingMark(itemId, ownerKey, drop) {
+    if (ownerKey && this.getHistoryCacheKey() !== ownerKey) return;
+    var changed = false;
+    for (var i = this.state.messages.length - 1; i >= 0; i--) {
+      var m = this.state.messages[i];
+      if (!m || m.role !== "assistant" || m._serverItemId !== itemId) continue;
+      if (!m._streamPending) continue;
+      if (drop && !m.content) {
+        this.state.messages.splice(i, 1);
+        changed = true;
+        continue;
+      }
+      m._streamPending = false;
+      changed = true;
+    }
+    if (changed) {
+      this.updateHistoryCache();
+      this.host.notify();
+    }
+  }
   /**
    * Stop and forget one item's poll. Used after a cancel: the row is either gone
    * (cancelled while queued) or flagged cancelled (cancelled while running), so
@@ -3797,7 +5287,12 @@ var ChatSession = class {
             dispatchItemId = initial.id;
             if (typeof params.onItemId === "function") params.onItemId(initial.id);
           }
-          var dp = self._fgPollWithEarlyProbe(initial, initial.id);
+          var dp = self._fgPollWithEarlyProbe(initial, initial.id, void 0, {
+            platform: params.aiPlatform,
+            projectId: params.projectId,
+            owner: params.owner,
+            ownerKey: params.key
+          });
           if (initial.id) self._trackPoll(initial.id, "fg", dp);
           return dp;
         }
@@ -4010,8 +5505,8 @@ var ChatSession = class {
         Promise.resolve(probeBgQueue(
           { service: svcId, owner, platform, queue, status, limit: WORKER_PASS_ADOPT_LIMIT },
           { maxAgeMs: 0 }
-        )).then(function(entry) {
-          settle(entry.result);
+        )).then(function(entry2) {
+          settle(entry2.result);
         }, function() {
           settle(null);
         });
@@ -4229,7 +5724,12 @@ var ChatSession = class {
         }
         if (serverId) self._stampTurnWithItemId(capturedKey, capturedQueuedLid, void 0, serverId);
         if (result && result.poll && (result.status === "pending" || result.status === "running")) {
-          var qp = self._fgPollWithEarlyProbe(result, serverId);
+          var qp = self._fgPollWithEarlyProbe(result, serverId, void 0, {
+            platform: capturedPlatform,
+            projectId: id.projectId,
+            owner: id.owner,
+            ownerKey: capturedKey
+          });
           if (serverId) self._trackPoll(serverId, "fg", qp);
           return qp.then(function(res) {
             if (isPollStopped(res)) return;
@@ -4500,9 +6000,14 @@ var ChatSession = class {
       answer = (answer || "").trim() || "No text response received from AI provider.";
       var lid = this._newLocalId();
       if (targetIdx >= 0 && this.state.messages[targetIdx] && this.state.messages[targetIdx].isPending) {
-        this.state.messages[targetIdx] = { role: "assistant", content: "", _localId: lid };
+        var qPainted = this._paintedTextAt(targetIdx);
+        var prevQ = this.state.messages[targetIdx] || {};
+        var qSettled = { role: "assistant", content: qPainted, _localId: lid };
+        if (prevQ._serverItemId) qSettled._serverItemId = prevQ._serverItemId;
+        if (prevQ._ownerKey) qSettled._ownerKey = prevQ._ownerKey;
+        this.state.messages[targetIdx] = qSettled;
         this.host.notify();
-        this.enqueueTypewrite(targetIdx, answer, lid);
+        this.enqueueTypewrite(targetIdx, answer, lid, qPainted);
       } else if (targetIdx >= 0) {
         this.state.messages.splice(targetIdx, 0, { role: "assistant", content: "", _localId: lid });
         this.host.notify();
@@ -4764,7 +6269,14 @@ var ChatSession = class {
   //     renders self-throttles to what the machine can actually paint.
   //   * rAF paces us to the browser's paint cycle and pauses in background
   //     tabs, so we never queue work faster than it can be drawn.
-  typewriteIntoIndex(idx, fullText, localId) {
+  //
+  // `paintedText` is what a LIVE STREAM already put in this bubble. The reveal
+  // starts from the point the two texts stop agreeing rather than from zero: the
+  // authoritative answer still replaces the live one character for character (it is
+  // the only source of truth, and this method writes fullText and nothing else), but
+  // retyping a paragraph the reader has just watched arrive is the one thing that
+  // would make a streamed turn look worse than an unstreamed one.
+  typewriteIntoIndex(idx, fullText, localId, paintedText) {
     var self = this;
     if (!fullText) return Promise.resolve();
     var CHARS_PER_SEC = 300;
@@ -4780,7 +6292,7 @@ var ChatSession = class {
     });
     this.state.typing = true;
     this.state.typingAbort = false;
-    var i = 0;
+    var i = paintedText ? typewriterResumeIndex(paintedText, fullText, regions) : 0;
     var last = nowMs();
     return new Promise(function(resolve) {
       var done = false;
@@ -4795,16 +6307,14 @@ var ChatSession = class {
         if (done) return;
         done = true;
         cleanup();
-        if (!self.state.typingAbort) {
-          var fi = localId ? self.state.messages.findIndex(function(mm) {
-            return mm._localId === localId;
-          }) : idx;
-          if (fi !== -1) {
-            var t = self.state.messages[fi];
-            if (t) {
-              t.content = fullText;
-              self.host.refreshMessageBubble(fi);
-            }
+        var fi = localId ? self.state.messages.findIndex(function(mm) {
+          return mm._localId === localId;
+        }) : idx;
+        if (fi !== -1) {
+          var t = self.state.messages[fi];
+          if (t) {
+            t.content = fullText;
+            self.host.refreshMessageBubble(fi);
           }
         }
         self.state.typing = false;
@@ -4863,12 +6373,13 @@ var ChatSession = class {
       nextFrame(frame);
     });
   }
-  enqueueTypewrite(idx, fullText, localId) {
+  enqueueTypewrite(idx, fullText, localId, paintedText) {
     var self = this;
     var target = this.state.messages[idx];
     if (target && target._ts === void 0) target._ts = wallClockNow();
+    if (!this.typewriterQueue) this.typewriterQueue = Promise.resolve();
     this.typewriterQueue = this.typewriterQueue.then(function() {
-      return self.typewriteIntoIndex(idx, fullText, localId);
+      return self.typewriteIntoIndex(idx, fullText, localId, paintedText);
     });
     return this.typewriterQueue;
   }
@@ -4901,12 +6412,17 @@ var ChatSession = class {
       this.promoteNextQueuedToRunning();
       return Promise.resolve();
     }
+    var painted = this._paintedTextAt(pendingIdx);
     var lid = this._newLocalId();
-    this.state.messages[pendingIdx] = { role: "assistant", content: "", isPending: false, _localId: lid };
+    var prevSettled = this.state.messages[pendingIdx] || {};
+    var settled = { role: "assistant", content: painted, isPending: false, _localId: lid };
+    if (prevSettled._serverItemId) settled._serverItemId = prevSettled._serverItemId;
+    if (prevSettled._ownerKey) settled._ownerKey = prevSettled._ownerKey;
+    this.state.messages[pendingIdx] = settled;
     this._removeStrayPendingAssistants();
     this.host.notify();
     this.promoteNextQueuedToRunning();
-    return this.enqueueTypewrite(pendingIdx, latest.content, lid);
+    return this.enqueueTypewrite(pendingIdx, latest.content, lid, painted);
   }
   // Remove leftover non-background pending ("Thinking…") assistant bubbles: the
   // duplicate that appears when a concurrent history refetch re-maps the still-
@@ -4936,6 +6452,7 @@ var ChatSession = class {
     for (var k = this.state.messages.length - 1; k >= 0; k--) {
       var m = this.state.messages[k];
       if (!m || !m.isPending || m.role !== "assistant" || m.isBackgroundTask) continue;
+      if (m._streaming) continue;
       if (this._isLiveImmediatePlaceholder(k)) continue;
       this.state.messages.splice(k, 1);
     }
@@ -5113,10 +6630,11 @@ var ChatSession = class {
         this.updateHistoryCache();
         return;
       }
+      var hPainted = this._paintedTextAt(idx);
       var lid = this._newLocalId();
-      this.state.messages[idx] = { role: "assistant", content: "", _localId: lid, _serverItemId: itemId };
+      this.state.messages[idx] = { role: "assistant", content: hPainted, _localId: lid, _serverItemId: itemId };
       this.host.notify();
-      this.enqueueTypewrite(idx, text, lid);
+      this.enqueueTypewrite(idx, text, lid, hPainted);
       this.updateHistoryCache();
       return;
     }
@@ -5158,11 +6676,11 @@ var ChatSession = class {
    *  path is project-relative ("report.xlsx"), and ONE ChatSession serves every
    *  project — unscoped, stopping a file in one project would silently suppress
    *  the same filename's continuations in another. */
-  _indexKeyOf(entry) {
-    if (!entry) return "";
-    var file = entry.storagePath || entry.filename;
+  _indexKeyOf(entry2) {
+    if (!entry2) return "";
+    var file = entry2.storagePath || entry2.filename;
     if (!file) return "";
-    return indexScopeKey(entry.projectId, entry.platform) + "|" + file;
+    return indexScopeKey(entry2.projectId, entry2.platform) + "|" + file;
   }
   /**
    * Reconcile the bg queue with the files the user has stopped.
@@ -5191,17 +6709,17 @@ var ChatSession = class {
       if (m.isPending || m.isPendingQueued || m.isPendingInProcess) surfaced[m._serverItemId] = true;
     });
     for (var i = this.bgTaskQueue.length - 1; i >= 0; i--) {
-      var entry = this.bgTaskQueue[i];
-      var key = this._indexKeyOf(entry);
+      var entry2 = this.bgTaskQueue[i];
+      var key = this._indexKeyOf(entry2);
       if (!key || !this.cancelledIndexKeys.has(key)) continue;
-      if (!entry.resumePass && !this.state.stoppedIndexIds[entry.id]) {
+      if (!entry2.resumePass && !this.state.stoppedIndexIds[entry2.id]) {
         this.cancelledIndexKeys.delete(key);
         continue;
       }
-      if (surfaced[entry.id]) continue;
+      if (surfaced[entry2.id]) continue;
       this.bgTaskQueue.splice(i, 1);
-      this._stopPoll(entry.id);
-      this._cancelServerItem(entry.id);
+      this._stopPoll(entry2.id);
+      this._cancelServerItem(entry2.id);
     }
   }
   /**
@@ -5259,8 +6777,8 @@ var ChatSession = class {
       return Promise.resolve(probeBgQueue(
         { service: svcId, owner, platform, queue, status, limit: WORKER_PASS_ADOPT_LIMIT },
         { maxAgeMs: 0 }
-      )).then(function(entry) {
-        return entry.result;
+      )).then(function(entry2) {
+        return entry2.result;
       }).catch(function() {
         return null;
       });
@@ -5413,30 +6931,30 @@ var ChatSession = class {
     }
     var bgPollBudget = MAX_CONCURRENT_BG_POLLS - this._countBgPolls();
     var injectedAny = false;
-    this.bgTaskQueue.forEach(function(entry) {
-      if (entry.projectId !== svcId || entry.platform !== plat) return;
-      if (!presentIds[entry.id]) {
-        var isRunning = entry.status === "running";
+    this.bgTaskQueue.forEach(function(entry2) {
+      if (entry2.projectId !== svcId || entry2.platform !== plat) return;
+      if (!presentIds[entry2.id]) {
+        var isRunning = entry2.status === "running";
         var userBubble = {
           role: "user",
-          content: self.host.formatIndexingLabel(entry.filename, entry.mime, entry.size, entry.storagePath, entry.isReindex, !!entry.resumePass),
+          content: self.host.formatIndexingLabel(entry2.filename, entry2.mime, entry2.size, entry2.storagePath, entry2.isReindex, !!entry2.resumePass),
           isBackgroundTask: true,
-          _serverItemId: entry.id,
+          _serverItemId: entry2.id,
           // Structured ref so this live pass groups with the same file's passes
           // rebuilt from history (see indexing_groups.buildChatDisplayList).
           _indexFile: {
-            name: entry.filename,
-            path: entry.storagePath,
-            mime: entry.mime,
-            size: entry.size,
-            isReindex: !!entry.isReindex,
-            continued: !!entry.resumePass
+            name: entry2.filename,
+            path: entry2.storagePath,
+            mime: entry2.mime,
+            size: entry2.size,
+            isReindex: !!entry2.isReindex,
+            continued: !!entry2.resumePass
           }
         };
         if (isRunning) userBubble.isPendingInProcess = true;
         else userBubble.isPendingQueued = true;
-        var stageAt = self._stageIndex(self.state.messages, entry.stageId);
-        var runningBubble = isRunning ? { role: "assistant", content: "", isPending: true, isPendingInProcess: true, isBackgroundTask: true, _serverItemId: entry.id } : null;
+        var stageAt = self._stageIndex(self.state.messages, entry2.stageId);
+        var runningBubble = isRunning ? { role: "assistant", content: "", isPending: true, isPendingInProcess: true, isBackgroundTask: true, _serverItemId: entry2.id } : null;
         if (stageAt === -1) {
           self.state.messages.push(userBubble);
           if (runningBubble) self.state.messages.push(runningBubble);
@@ -5445,16 +6963,16 @@ var ChatSession = class {
         } else {
           self.state.messages.splice(stageAt, 0, userBubble);
         }
-        presentIds[entry.id] = true;
+        presentIds[entry2.id] = true;
         injectedAny = true;
       }
-      if (bgPollBudget > 0 && !self.isPollingPaused() && !self.historyItemPolls.has(entry.id) && typeof entry.poll === "function") {
+      if (bgPollBudget > 0 && !self.isPollingPaused() && !self.historyItemPolls.has(entry2.id) && typeof entry2.poll === "function") {
         bgPollBudget--;
-        var capturedId = entry.id, capturedPlat = plat;
-        var capturedEntry = entry;
+        var capturedId = entry2.id, capturedPlat = plat;
+        var capturedEntry = entry2;
         var wasStopped = false;
-        var bp = entry.poll({ latency: POLL_INTERVAL });
-        self._trackPoll(entry.id, "bg", bp);
+        var bp = entry2.poll({ latency: POLL_INTERVAL });
+        self._trackPoll(entry2.id, "bg", bp);
         bp.then(function(response) {
           if (isPollStopped(response)) {
             wasStopped = true;
@@ -5520,13 +7038,13 @@ var ChatSession = class {
    *  client knows DETERMINISTICALLY (see the two call sites in
    *  maybeResumeIndexing). Best-effort by contract; identity-checked so a
    *  project switch mid-settle cannot stamp the wrong service. */
-  _mintDoneMarker(entry) {
+  _mintDoneMarker(entry2) {
     try {
       var mint = chatEngineConfig().mintIndexDoneMarker;
-      if (!mint || !entry || !entry.storagePath || !entry.projectId) return;
+      if (!mint || !entry2 || !entry2.storagePath || !entry2.projectId) return;
       var id = this.host.getIdentity();
-      if (!id || id.projectId !== entry.projectId) return;
-      mint({ service: entry.projectId, storagePath: entry.storagePath });
+      if (!id || id.projectId !== entry2.projectId) return;
+      mint({ service: entry2.projectId, storagePath: entry2.storagePath });
     } catch (_e) {
     }
   }
@@ -5547,27 +7065,27 @@ var ChatSession = class {
    *  maybeResumeIndexing's single-pass branch); paged files stay with their
    *  drivers. Outcome is read from the settled bubbles' own flags, which is
    *  all the history mapping left us. Best-effort and idempotent throughout. */
-  _flipRunFromSettledEntry(entry) {
+  _flipRunFromSettledEntry(entry2) {
     try {
-      if (!entry || !entry.storagePath || !entry.id || !entry.projectId) return;
-      if (isPagedReadFile(entry.filename, entry.mime)) return;
-      if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
-      if (this.state.stoppedIndexIds[entry.id]) return;
+      if (!entry2 || !entry2.storagePath || !entry2.id || !entry2.projectId) return;
+      if (isPagedReadFile(entry2.filename, entry2.mime)) return;
+      if (this.cancelledIndexKeys.has(this._indexKeyOf(entry2))) return;
+      if (this.state.stoppedIndexIds[entry2.id]) return;
       var userMsg = null, replyMsg = null;
       this.state.messages.forEach(function(m) {
-        if (m._serverItemId !== entry.id) return;
+        if (m._serverItemId !== entry2.id) return;
         if (m.role === "user") {
           if (!userMsg) userMsg = m;
         } else if (!replyMsg) replyMsg = m;
       });
       if (userMsg && userMsg.isCancelled || replyMsg && replyMsg.isCancelled) {
-        this._flipRunRecord(entry, "cancelled");
+        this._flipRunRecord(entry2, "cancelled");
       } else if (replyMsg && replyMsg.isError) {
         var errText = typeof replyMsg.content === "string" ? replyMsg.content.replace(/\s+/g, " ").trim().slice(0, 300) : "";
-        this._flipRunRecord(entry, "error", errText || "Indexing failed.");
+        this._flipRunRecord(entry2, "error", errText || "Indexing failed.");
       } else if (replyMsg) {
-        this._mintDoneMarker(entry);
-        this._flipRunRecord(entry, "done");
+        this._mintDoneMarker(entry2);
+        this._flipRunRecord(entry2, "done");
       }
     } catch (_e) {
     }
@@ -5578,55 +7096,55 @@ var ChatSession = class {
    *  mid-settle — otherwise the record lies 'working' forever. Best-effort
    *  through upsertIndexRunRecordSafe; the consumer's precedence guard keeps
    *  repeats and races harmless. */
-  _flipRunRecord(entry, status, error) {
-    if (!entry || !entry.storagePath || !entry.projectId) return;
+  _flipRunRecord(entry2, status, error) {
+    if (!entry2 || !entry2.storagePath || !entry2.projectId) return;
     var patch = { status, finished: Date.now() };
     if (error) patch.error = error;
-    upsertIndexRunRecordSafe(entry.projectId, entry.storagePath, patch);
+    upsertIndexRunRecordSafe(entry2.projectId, entry2.storagePath, patch);
   }
-  maybeResumeIndexing(entry, response, platform) {
+  maybeResumeIndexing(entry2, response, platform) {
     var self = this;
     var endOfClientChain = function() {
       self._nudgeIndexingDrain();
     };
     try {
-      if (!entry || !entry.storagePath) return;
-      if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
-      if (!isPagedReadFile(entry.filename, entry.mime)) {
+      if (!entry2 || !entry2.storagePath) return;
+      if (this.cancelledIndexKeys.has(this._indexKeyOf(entry2))) return;
+      if (!isPagedReadFile(entry2.filename, entry2.mime)) {
         if (!isErrorResponseBody(response) && !this._isCancelledPollResult(response)) {
-          this._mintDoneMarker(entry);
-          this._flipRunRecord(entry, "done");
+          this._mintDoneMarker(entry2);
+          this._flipRunRecord(entry2, "done");
         } else if (this._isCancelledPollResult(response)) {
-          this._flipRunRecord(entry, "cancelled");
+          this._flipRunRecord(entry2, "cancelled");
         } else {
-          this._flipRunRecord(entry, "error", this._runErrorText(response));
+          this._flipRunRecord(entry2, "error", this._runErrorText(response));
         }
         endOfClientChain();
         return;
       }
-      if (isImageVisionFile(entry.filename, entry.mime)) return;
-      if (windowedIndexingEnabled() && isWindowedReadFile(entry.filename, entry.mime)) return;
+      if (isImageVisionFile(entry2.filename, entry2.mime)) return;
+      if (windowedIndexingEnabled() && isWindowedReadFile(entry2.filename, entry2.mime)) return;
       if (isErrorResponseBody(response)) {
-        this._flipRunRecord(entry, "error", this._runErrorText(response));
+        this._flipRunRecord(entry2, "error", this._runErrorText(response));
         endOfClientChain();
         return;
       }
       var answer = (platform === "openai" ? extractOpenAIText(response) : extractClaudeText(response)) || "";
       if (answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1) {
-        this._mintDoneMarker(entry);
-        this._flipRunRecord(entry, "done");
+        this._mintDoneMarker(entry2);
+        this._flipRunRecord(entry2, "done");
         endOfClientChain();
         return;
       }
-      var pass = (entry.resumePass || 0) + 1;
+      var pass = (entry2.resumePass || 0) + 1;
       if (pass > MAX_INDEXING_RESUME_PASSES) {
-        this._flipRunRecord(entry, "error", "Stopped after " + MAX_INDEXING_RESUME_PASSES + " passes without finishing.");
+        this._flipRunRecord(entry2, "error", "Stopped after " + MAX_INDEXING_RESUME_PASSES + " passes without finishing.");
         endOfClientChain();
         return;
       }
       var id = this.host.getIdentity();
-      if (!id || id.platform === "none" || id.projectId !== entry.projectId) {
-        this._flipRunRecord(entry, "error", "Indexing stopped: the session or project changed before the file finished.");
+      if (!id || id.platform === "none" || id.projectId !== entry2.projectId) {
+        this._flipRunRecord(entry2, "error", "Indexing stopped: the session or project changed before the file finished.");
         endOfClientChain();
         return;
       }
@@ -5644,10 +7162,10 @@ var ChatSession = class {
         serviceName: id.serviceName,
         serviceDescription: id.serviceDescription,
         attachment: {
-          name: entry.filename,
-          storagePath: entry.storagePath,
-          mime: entry.mime,
-          size: entry.size,
+          name: entry2.filename,
+          storagePath: entry2.storagePath,
+          mime: entry2.mime,
+          size: entry2.size,
           url: ""
         }
       }).then(function(ack) {
@@ -5656,11 +7174,11 @@ var ChatSession = class {
             projectId: id.projectId,
             platform: id.platform,
             id: ack.id,
-            filename: entry.filename,
-            storagePath: entry.storagePath,
-            isReindex: entry.isReindex,
-            mime: entry.mime,
-            size: entry.size,
+            filename: entry2.filename,
+            storagePath: entry2.storagePath,
+            isReindex: entry2.isReindex,
+            mime: entry2.mime,
+            size: entry2.size,
             status: ack.status === "running" ? "running" : "pending",
             poll: ack.poll,
             resumePass: pass
@@ -5747,6 +7265,7 @@ var ChatSession = class {
         formatIndexingLabel: self.host.formatIndexingLabel
       }).messages;
       self.applyHydratedBodies(mapped);
+      self._adoptLocalAnswers(mapped, loadKey);
       var keptOlderPages = false;
       var keptScreenAwaitingBg = false;
       if (fetchMore) {
@@ -5922,6 +7441,7 @@ var ChatSession = class {
       }
       self.updateHistoryCache();
       self.host.notify();
+      self._scheduleStreamRecovery(loadKey, platform, projectId, owner);
       var bgPending = !fetchMore && history && history.bgPending;
       if (bgPending) {
         var batchId = ++_bgHistoryBatchSeq;
@@ -6071,7 +7591,12 @@ var ChatSession = class {
               }
             }
           };
-          var pp = isBg ? item.poll(Object.assign({ latency: POLL_INTERVAL }, pollOpts)) : self._fgPollWithEarlyProbe(item, capturedId, pollOpts);
+          var pp = isBg ? item.poll(Object.assign({ latency: POLL_INTERVAL }, pollOpts)) : self._fgPollWithEarlyProbe(item, capturedId, pollOpts, {
+            platform,
+            projectId,
+            owner,
+            ownerKey: loadKey
+          });
           self._trackPoll(capturedId, item._isBgTask || item._isOnBgQueue ? "bg" : "fg", pp);
           if (pp && pp.catch) pp.catch(function() {
           });
@@ -6741,6 +8266,112 @@ function buildChatDisplayList(messages, opts) {
   return out;
 }
 
+// src/engine/project_settings.ts
+var UPLOAD_ACCESS_GROUPS = ["public", "authorized", "private"];
+var DEFAULT_UPLOAD_ACCESS_GROUP = "authorized";
+var PROJECT_SETTINGS_TABLE = "__SETTINGS__";
+var PROJECT_SETTINGS_UNIQUE_ID = "bq::settings";
+var PROJECT_SETTINGS_ACCESS_GROUP = "public";
+var UPLOAD_ACCESS_LABELS = {
+  public: "Public",
+  authorized: "Signed in users",
+  private: "Only me"
+};
+var UPLOAD_ACCESS_HINTS = {
+  public: "Anyone can ask about this file, including visitors who are not logged in.",
+  authorized: "Only users signed in to this project can ask about this file.",
+  private: "Only you can ask about this file."
+};
+var UPLOAD_ACCESS_OPTIONS = UPLOAD_ACCESS_GROUPS.map((value) => ({
+  value,
+  label: UPLOAD_ACCESS_LABELS[value],
+  hint: UPLOAD_ACCESS_HINTS[value]
+}));
+function normalizeUploadAccessGroup(value) {
+  return UPLOAD_ACCESS_GROUPS.indexOf(value) === -1 ? DEFAULT_UPLOAD_ACCESS_GROUP : value;
+}
+function normalizeProjectAccessSetting(value) {
+  if (value === "ask") return "ask";
+  return UPLOAD_ACCESS_GROUPS.indexOf(value) === -1 ? null : value;
+}
+function accessSettingFrom(data) {
+  return normalizeProjectAccessSetting(data?.upload_access_group);
+}
+function uploadAccessGroupFrom(data) {
+  const v = accessSettingFrom(data);
+  return v && v !== "ask" ? v : DEFAULT_UPLOAD_ACCESS_GROUP;
+}
+function asksUploadAccessFrom(data) {
+  return accessSettingFrom(data) === "ask";
+}
+var reader = null;
+var cache = /* @__PURE__ */ new Map();
+function configureProjectSettings(fn) {
+  reader = fn;
+}
+function entry(service) {
+  let e = cache.get(service);
+  if (!e) {
+    e = { data: null, settled: false, inflight: null };
+    cache.set(service, e);
+  }
+  return e;
+}
+function loadProjectSettings(service) {
+  if (!service) return Promise.resolve(null);
+  const e = entry(service);
+  if (e.settled) return Promise.resolve(e.data);
+  if (e.inflight) return e.inflight;
+  if (!reader) return Promise.resolve(null);
+  const run = reader(service).then((data) => data && typeof data === "object" ? data : null).catch(() => null).then((data) => {
+    const cur = entry(service);
+    if (cur.inflight === run) {
+      cur.data = data;
+      cur.settled = true;
+      cur.inflight = null;
+    }
+    return data;
+  });
+  e.inflight = run;
+  return run;
+}
+function primeProjectSettings(service) {
+  void loadProjectSettings(service);
+}
+function readyProjectSettings(service) {
+  return loadProjectSettings(service);
+}
+function cachedProjectSettings(service) {
+  const e = cache.get(service);
+  return e && e.settled ? e.data : null;
+}
+function projectSettingsSettled(service) {
+  const e = cache.get(service);
+  return !!e && e.settled;
+}
+function projectAccessSetting(service) {
+  return accessSettingFrom(cachedProjectSettings(service));
+}
+function projectUploadAccessGroup(service) {
+  return uploadAccessGroupFrom(cachedProjectSettings(service));
+}
+function projectAsksUploadAccess(service) {
+  return asksUploadAccessFrom(cachedProjectSettings(service));
+}
+function setProjectSettings(service, data) {
+  if (!service) return;
+  cache.set(service, { data: data || null, settled: true, inflight: null });
+}
+function patchProjectSettings(service, patch) {
+  if (!service) return;
+  const cur = cachedProjectSettings(service) || {};
+  setProjectSettings(service, Object.assign({}, cur, patch));
+}
+function clearProjectSettings(service) {
+  if (service) cache.delete(service);
+  else cache.clear();
+}
+
 exports.BG_INDEXING_QUEUE_SUFFIX = BG_INDEXING_QUEUE_SUFFIX;
 exports.BOM = BOM;
 exports.BOM_EXTS = BOM_EXTS;
@@ -6752,6 +8383,7 @@ exports.ChatSession = ChatSession;
 exports.DEFAULT_CLAUDE_MODEL = DEFAULT_CLAUDE_MODEL;
 exports.DEFAULT_CONTEXT_WINDOW = DEFAULT_CONTEXT_WINDOW;
 exports.DEFAULT_OPENAI_MODEL = DEFAULT_OPENAI_MODEL;
+exports.DEFAULT_UPLOAD_ACCESS_GROUP = DEFAULT_UPLOAD_ACCESS_GROUP;
 exports.EMPTY_INDEXING_REPLY = EMPTY_INDEXING_REPLY;
 exports.EXPIRED_ATTACHMENT_URL_HOST = EXPIRED_ATTACHMENT_URL_HOST;
 exports.EXPIRED_ATTACHMENT_URL_ORIGIN = EXPIRED_ATTACHMENT_URL_ORIGIN;
@@ -6764,6 +8396,7 @@ exports.HTML_EXTS = HTML_EXTS;
 exports.HTML_HEAD_WINDOW = HTML_HEAD_WINDOW;
 exports.IMAGE_PREVIEWS_PER_MESSAGE = IMAGE_PREVIEWS_PER_MESSAGE;
 exports.INDEXING_COMPLETE_MARKER = INDEXING_COMPLETE_MARKER;
+exports.INDEXING_MAX_OUTPUT_TOKENS = INDEXING_MAX_OUTPUT_TOKENS;
 exports.INLINE_LINK_GLYPH = INLINE_LINK_GLYPH;
 exports.INLINE_LINK_UNAVAILABLE_GLYPH = INLINE_LINK_UNAVAILABLE_GLYPH;
 exports.INLINE_LINK_UNAVAILABLE_SUFFIX = INLINE_LINK_UNAVAILABLE_SUFFIX;
@@ -6787,13 +8420,24 @@ exports.PREVIEWABLE_IMAGE_CONTENT_TYPES = PREVIEWABLE_IMAGE_CONTENT_TYPES;
 exports.PREVIEW_BROWSER_CACHE_SECONDS = PREVIEW_BROWSER_CACHE_SECONDS;
 exports.PREVIEW_LAYOUT_BOX_SELECTOR = PREVIEW_LAYOUT_BOX_SELECTOR;
 exports.PREVIEW_URL_EXPIRES_SECONDS = PREVIEW_URL_EXPIRES_SECONDS;
+exports.PROJECT_SETTINGS_ACCESS_GROUP = PROJECT_SETTINGS_ACCESS_GROUP;
+exports.PROJECT_SETTINGS_TABLE = PROJECT_SETTINGS_TABLE;
+exports.PROJECT_SETTINGS_UNIQUE_ID = PROJECT_SETTINGS_UNIQUE_ID;
 exports.RENDER_FROM_TOKEN = RENDER_FROM_TOKEN;
 exports.RTF_EXTS = RTF_EXTS;
 exports.RUN_RECORD_WORKING_STALE_MS = RUN_RECORD_WORKING_STALE_MS;
+exports.STREAM_POLL_INTERVAL = STREAM_POLL_INTERVAL;
 exports.TOOL_AND_RESPONSE_BUFFER = TOOL_AND_RESPONSE_BUFFER;
+exports.UPLOAD_ACCESS_GROUPS = UPLOAD_ACCESS_GROUPS;
+exports.UPLOAD_ACCESS_HINTS = UPLOAD_ACCESS_HINTS;
+exports.UPLOAD_ACCESS_LABELS = UPLOAD_ACCESS_LABELS;
+exports.UPLOAD_ACCESS_OPTIONS = UPLOAD_ACCESS_OPTIONS;
 exports.XML_EXTS = XML_EXTS;
 exports.__resetSplitHistoryState = __resetSplitHistoryState;
+exports.accessSettingFrom = accessSettingFrom;
+exports.adoptLocalAnswerIntoPage = adoptLocalAnswerIntoPage;
 exports.applyEncodingDeclaration = applyEncodingDeclaration;
+exports.asksUploadAccessFrom = asksUploadAccessFrom;
 exports.bgIndexingQueueName = bgIndexingQueueName;
 exports.buildAiAgentValue = buildAiAgentValue;
 exports.buildBoundedChatMessages = buildBoundedChatMessages;
@@ -6808,21 +8452,27 @@ exports.buildIndexingRenderMessage = buildIndexingRenderMessage;
 exports.buildIndexingSystemPrompt = buildIndexingSystemPrompt;
 exports.buildIndexingUserMessage = buildIndexingUserMessage;
 exports.buildIndexingWindowMessage = buildIndexingWindowMessage;
+exports.cachedProjectSettings = cachedProjectSettings;
 exports.callClaudeWithMcp = callClaudeWithMcp;
 exports.callClaudeWithPublicMcp = callClaudeWithPublicMcp;
 exports.callOpenAIWithPublicMcp = callOpenAIWithPublicMcp;
 exports.canonicalizePathForm = canonicalizePathForm;
 exports.chatCacheKey = chatCacheKey;
 exports.chatEngineConfig = chatEngineConfig;
+exports.chatStreamWiring = chatStreamWiring;
 exports.classifyInlineLink = classifyInlineLink;
 exports.clearAttachmentParsers = clearAttachmentParsers;
 exports.clearImagePreviewCache = clearImagePreviewCache;
+exports.clearProjectSettings = clearProjectSettings;
 exports.composeUserMessage = composeUserMessage;
 exports.configureChatEngine = configureChatEngine;
+exports.configureProjectSettings = configureProjectSettings;
 exports.contentTypeForExt = contentTypeForExt;
 exports.createHistoryFiller = createHistoryFiller;
 exports.createInlineLinkRegex = createInlineLinkRegex;
 exports.createScrollAnchor = createScrollAnchor;
+exports.createSseParser = createSseParser;
+exports.csrEnvelopeError = csrEnvelopeError;
 exports.encodePathSegments = encodePathSegments;
 exports.encodingClassForExt = encodingClassForExt;
 exports.ensureHtmlCharset = ensureHtmlCharset;
@@ -6860,36 +8510,46 @@ exports.indexScopeKey = indexScopeKey;
 exports.indexingAccessGroup = indexingAccessGroup;
 exports.isAuthExpiredError = isAuthExpiredError;
 exports.isBgIndexingQueue = isBgIndexingQueue;
+exports.isCsrStatusEnvelope = isCsrStatusEnvelope;
 exports.isErrorResponseBody = isErrorResponseBody;
 exports.isHttpUrlLike = isHttpUrlLike;
+exports.isImageVisionFile = isImageVisionFile;
 exports.isIndexingRequestText = isIndexingRequestText;
 exports.isLinkUnavailable = isLinkUnavailable;
 exports.isNonRetryableRequestError = isNonRetryableRequestError;
 exports.isOfficeFile = isOfficeFile;
+exports.isPagedReadFile = isPagedReadFile;
 exports.isPreviewableImagePath = isPreviewableImagePath;
 exports.isProviderApiKeyError = isProviderApiKeyError;
 exports.isServerExtractable = isServerExtractable;
 exports.isServiceDbAttachmentHref = isServiceDbAttachmentHref;
+exports.isWindowedReadFile = isWindowedReadFile;
 exports.linkUnavailableKeyForHref = linkUnavailableKeyForHref;
 exports.linkUnavailableKeyForPath = linkUnavailableKeyForPath;
 exports.linkUnavailableKeysForPath = linkUnavailableKeysForPath;
 exports.listClaudeModels = listClaudeModels;
 exports.listOpenAIModels = listOpenAIModels;
+exports.liveSafePrefix = liveSafePrefix;
+exports.loadProjectSettings = loadProjectSettings;
 exports.looksLikeRtf = looksLikeRtf;
 exports.makeExtractPlaceholder = makeExtractPlaceholder;
 exports.mapHistoryListToMessages = mapHistoryListToMessages;
 exports.markImagePreviewStale = markImagePreviewStale;
+exports.mayKeepStreamedAnswer = mayKeepStreamedAnswer;
 exports.mintCacheBustStamp = mintCacheBustStamp;
 exports.needsBomForExt = needsBomForExt;
 exports.normalizeAttachmentPathCandidate = normalizeAttachmentPathCandidate;
 exports.normalizeExt = normalizeExt;
+exports.normalizeProjectAccessSetting = normalizeProjectAccessSetting;
 exports.normalizeTextContent = normalizeTextContent;
 exports.normalizeTrailingInlineToken = normalizeTrailingInlineToken;
+exports.normalizeUploadAccessGroup = normalizeUploadAccessGroup;
 exports.notifyAgentSaveAttachment = notifyAgentSaveAttachment;
 exports.parseAiAgentValue = parseAiAgentValue;
 exports.parseAttachmentContent = parseAttachmentContent;
 exports.parseIndexingLabel = parseIndexingLabel;
 exports.parseIndexingRequestText = parseIndexingRequestText;
+exports.patchProjectSettings = patchProjectSettings;
 exports.peekImagePreviewUrl = peekImagePreviewUrl;
 exports.prepareDownloadText = prepareDownloadText;
 exports.presignExpiryEpochMs = presignExpiryEpochMs;
@@ -6897,7 +8557,13 @@ exports.previewImageContentType = previewImageContentType;
 exports.previewLayoutBox = previewLayoutBox;
 exports.previewMintCacheToken = previewMintCacheToken;
 exports.previewableExtOf = previewableExtOf;
+exports.primeProjectSettings = primeProjectSettings;
+exports.projectAccessSetting = projectAccessSetting;
+exports.projectAsksUploadAccess = projectAsksUploadAccess;
+exports.projectSettingsSettled = projectSettingsSettled;
+exports.projectUploadAccessGroup = projectUploadAccessGroup;
 exports.readExpiredAttachmentHref = readExpiredAttachmentHref;
+exports.readyProjectSettings = readyProjectSettings;
 exports.registerAttachmentParser = registerAttachmentParser;
 exports.registerModelContextWindows = registerModelContextWindows;
 exports.renderInlineLinkHtml = renderInlineLinkHtml;
@@ -6908,11 +8574,18 @@ exports.runIndexUniqueId = runIndexUniqueId;
 exports.safeDecodeURIComponent = safeDecodeURIComponent;
 exports.sanitizeAttachmentLinksForHistory = sanitizeAttachmentLinksForHistory;
 exports.setProjectContextWindow = setProjectContextWindow;
+exports.setProjectSettings = setProjectSettings;
 exports.shouldRescueInFlightMessage = shouldRescueInFlightMessage;
+exports.skapiSupportsStreaming = skapiSupportsStreaming;
+exports.streamRecoveryEnabled = streamRecoveryEnabled;
+exports.streamRecoveryLabels = streamRecoveryLabels;
+exports.streamRecoveryPhase = streamRecoveryPhase;
 exports.stripFileBlocksFromHistory = stripFileBlocksFromHistory;
 exports.transformContentWithImages = transformContentWithImages;
 exports.transformContentWithOpenAIImages = transformContentWithOpenAIImages;
 exports.truncateLabelForDisplay = truncateLabelForDisplay;
+exports.typewriterResumeIndex = typewriterResumeIndex;
+exports.uploadAccessGroupFrom = uploadAccessGroupFrom;
 exports.upsertIndexRunRecordSafe = upsertIndexRunRecordSafe;
 exports.wallClockNow = wallClockNow;
 //# sourceMappingURL=engine.cjs.map