bunnyquery 1.8.0 → 1.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunnyquery",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "Embeddable BunnyQuery AI chat widget + its framework-agnostic chat engine",
   "main": "bunnyquery.js",
   "exports": {

package/src/engine/ai_agent.ts

@@ -0,0 +1,80 @@
+/**
+ * The `ai_agent` service option, parsed and serialized in ONE place.
+ *
+ * Stored on the skapi service record as up to three '#'-delimited segments:
+ *
+ *   none                                  AI chat disabled
+ *   claude                                platform chosen, no model saved yet
+ *   claude#claude-sonnet-4-6              platform + model
+ *   claude#claude-sonnet-4-6#400000       platform + model + context-window override
+ *
+ * The third segment is new and optional, so every value written before it
+ * existed parses unchanged with `contextWindow: null`. Nothing writes a third
+ * segment without a model, because the window is meaningless without one.
+ *
+ * This lived as four separate copies (agent.vue, dbfile.vue, service.vue, and
+ * the widget's index.js), which is how the format drifts. New callers should
+ * import from here rather than re-deriving the split.
+ */
+
+export type AiAgentPlatform = 'claude' | 'openai' | null;
+
+export type ParsedAiAgent = {
+	/** null when unset or explicitly 'none'. */
+	platform: AiAgentPlatform;
+	/** '' when no model has been saved. */
+	model: string;
+	/** Per-project context-window override in tokens, or null to use the model's. */
+	contextWindow: number | null;
+	/** True when a real platform is configured (i.e. not unset and not 'none'). */
+	hasPlatform: boolean;
+};
+
+function normalizePlatform(raw: string): AiAgentPlatform {
+	var p = (raw || '').trim().toLowerCase();
+	return p === 'claude' || p === 'openai' ? p : null;
+}
+
+export function parseAiAgentValue(value: string | null | undefined): ParsedAiAgent {
+	var raw = (value || '').trim();
+	if (!raw || raw.toLowerCase() === 'none') {
+		return { platform: null, model: '', contextWindow: null, hasPlatform: false };
+	}
+
+	// Split into at most three parts so a '#' inside a model id (none today, but
+	// the delimiter should not be load-bearing on the tail) cannot shift fields.
+	var firstHash = raw.indexOf('#');
+	if (firstHash === -1) {
+		var only = normalizePlatform(raw);
+		return { platform: only, model: '', contextWindow: null, hasPlatform: !!only };
+	}
+
+	var platform = normalizePlatform(raw.slice(0, firstHash));
+	var rest = raw.slice(firstHash + 1);
+	var secondHash = rest.indexOf('#');
+	var model = (secondHash === -1 ? rest : rest.slice(0, secondHash)).trim();
+	var windowRaw = secondHash === -1 ? '' : rest.slice(secondHash + 1).trim();
+
+	var parsedWindow = windowRaw ? Number(windowRaw) : NaN;
+	var contextWindow = Number.isFinite(parsedWindow) && parsedWindow > 0
+		? Math.floor(parsedWindow)
+		: null;
+
+	return { platform: platform, model: model, contextWindow: contextWindow, hasPlatform: !!platform };
+}
+
+export function buildAiAgentValue(
+	platform: string | null | undefined,
+	model?: string | null,
+	contextWindow?: number | null,
+): string {
+	var p = (platform || '').trim().toLowerCase();
+	if (!p || p === 'none') return 'none';
+
+	var m = (model || '').trim();
+	if (!m) return p;
+
+	var n = Number(contextWindow);
+	if (!Number.isFinite(n) || n <= 0) return p + '#' + m;
+	return p + '#' + m + '#' + Math.floor(n);
+}

package/src/engine/budget.ts

@@ -7,15 +7,76 @@
 import { sanitizeAttachmentLinksForHistory } from './links';
 
 export var CONTEXT_WINDOW_DEFAULT: Record<string, number> = { claude: 200000, openai: 128000 };
+// Exact model ids first, then family keys (see getContextWindow: a suffixed id
+// falls back to its family rather than to the platform default). Claude figures
+// come from Anthropic's published model table; `max_input_tokens` from
+// /v1/models overrides all of this at runtime when a listing has been seen.
+// 'claude-opus-4-7' read 200000 here, which was wrong by 5x, and the default
+// Claude model 'claude-sonnet-4-6' was absent entirely so it fell through to
+// CONTEXT_WINDOW_DEFAULT.claude. Neither was observable, because the history
+// budget and the Claude per-request cap below bind long before the window does.
 export var CONTEXT_WINDOW_BY_MODEL: Record<string, number> = {
-	'claude-opus-4-7': 200000, 'claude-sonnet-4': 200000, 'gpt-5.4': 128000,
+	// exact ids
+	'claude-opus-5': 1000000, 'claude-opus-4-8': 1000000, 'claude-opus-4-7': 1000000,
+	'claude-sonnet-5': 1000000, 'claude-sonnet-4-6': 1000000, 'claude-sonnet-4': 200000,
+	'claude-haiku-4-5': 200000, 'gpt-5.4': 128000, 'gpt-5.6-luna': 128000,
+	// family keys
+	'claude-opus': 1000000, 'claude-sonnet': 1000000, 'claude-haiku': 200000,
+	'gpt-5.6': 128000, 'gpt-5': 128000,
 };
+
+// Context windows reported by a provider's own models listing, keyed by model id.
+// Anthropic's GET /v1/models returns `max_input_tokens` per model, which is the
+// authoritative context window; OpenAI's listing carries no equivalent field, so
+// OpenAI models resolve from the table above. Populated by
+// registerModelContextWindows() when a client fetches its model list.
+var apiReportedContextWindows: Record<string, number> = {};
+
+/**
+ * Record context windows from a provider models listing. Accepts the raw list
+ * items and reads `max_input_tokens` (Anthropic); items without it are skipped,
+ * so passing an OpenAI listing is a no-op rather than an error.
+ */
+export function registerModelContextWindows(models: Array<{ id?: string; max_input_tokens?: number }> | null | undefined): void {
+	if (!Array.isArray(models)) return;
+	for (var i = 0; i < models.length; i++) {
+		var m = models[i];
+		var id = (m && m.id ? String(m.id) : '').trim().toLowerCase();
+		var reported = m ? Number(m.max_input_tokens) : NaN;
+		if (id && Number.isFinite(reported) && reported > 0) {
+			apiReportedContextWindows[id] = Math.floor(reported);
+		}
+	}
+}
+
+/** Per-project override, keyed by service id. Set from the project settings. */
+var projectContextWindows: Record<string, number> = {};
+
+export function setProjectContextWindow(serviceId: string, tokens: number | null | undefined): void {
+	var key = (serviceId || '').trim();
+	if (!key) return;
+	var n = Number(tokens);
+	if (Number.isFinite(n) && n > 0) projectContextWindows[key] = Math.floor(n);
+	else delete projectContextWindows[key];
+}
+
+export function getProjectContextWindow(serviceId: string): number | null {
+	var key = (serviceId || '').trim();
+	return key && projectContextWindows[key] ? projectContextWindows[key] : null;
+}
 export var OUTPUT_TOKEN_RESERVE = 22000;
 export var TOOL_AND_RESPONSE_BUFFER = 4000;
 export var MIN_INPUT_TOKEN_BUDGET = 8000;
 export var CLAUDE_PER_REQUEST_INPUT_CAP = 28000;
 export var MAX_HISTORY_MESSAGES = 20;
 export var HISTORY_TOKEN_BUDGET = 8000;
+// Ratios that scale the two ceilings above off the resolved context window.
+// Calibrated to reproduce the previous fixed values at the default windows:
+// claude 200000 -> cap 27840 (was 28000, so the 28000 floor holds), and
+// openai 128000 -> history 8160 (~the previous 8000). Both are floored at the
+// old constants, so these can only ever raise a budget, never lower one.
+export var CLAUDE_INPUT_CAP_RATIO = 0.16;
+export var HISTORY_BUDGET_RATIO = 0.08;
 
 export function estimateTextTokens(text: string): number {
 	return Math.ceil((text || '').length / 3);
@@ -25,9 +86,34 @@ export function estimateMessageTokens(msg: { role: string; content: string }): n
 	return estimateTextTokens(msg.content) + estimateTextTokens(msg.role) + 6;
 }
 
-export function getContextWindow(platform: string, model?: string): number {
+/**
+ * Resolve a model's context window, most specific source first:
+ *   1. per-project override (project settings)
+ *   2. the provider's own models listing (Anthropic `max_input_tokens`)
+ *   3. an exact entry in CONTEXT_WINDOW_BY_MODEL
+ *   4. a family entry, by dropping trailing '-' segments off the id
+ *   5. the platform default
+ *
+ * Step 4 is why a new or suffixed id no longer drops straight to the platform
+ * default: 'gpt-5.6-luna' resolves via 'gpt-5.6', and a dated Claude snapshot
+ * such as 'claude-opus-4-7-20260101' resolves via 'claude-opus-4-7'. The walk
+ * stops at the first hit, so a more specific entry always wins over its family.
+ */
+export function getContextWindow(platform: string, model?: string, serviceId?: string): number {
+	var override = serviceId ? getProjectContextWindow(serviceId) : null;
+	if (override) return override;
+
 	var normalized = (model || '').trim().toLowerCase();
-	if (normalized && CONTEXT_WINDOW_BY_MODEL[normalized]) return CONTEXT_WINDOW_BY_MODEL[normalized];
+	if (normalized) {
+		if (apiReportedContextWindows[normalized]) return apiReportedContextWindows[normalized];
+		if (CONTEXT_WINDOW_BY_MODEL[normalized]) return CONTEXT_WINDOW_BY_MODEL[normalized];
+
+		var parts = normalized.split('-');
+		for (var end = parts.length - 1; end > 0; end--) {
+			var family = parts.slice(0, end).join('-');
+			if (CONTEXT_WINDOW_BY_MODEL[family]) return CONTEXT_WINDOW_BY_MODEL[family];
+		}
+	}
 	return CONTEXT_WINDOW_DEFAULT[platform];
 }
 
@@ -46,14 +132,34 @@ export type BoundedChatOptions = {
 };
 
 export function buildBoundedChatMessages(options: BoundedChatOptions) {
-	var contextWindow = getContextWindow(options.platform, options.model);
+	var contextWindow = getContextWindow(options.platform, options.model, options.serviceId);
 	var contextBasedBudget = Math.max(MIN_INPUT_TOKEN_BUDGET,
 		contextWindow - OUTPUT_TOKEN_RESERVE - TOOL_AND_RESPONSE_BUFFER);
+	// Scaling is gated on an EXPLICIT per-project window set from project
+	// settings. Without one, the fixed ceilings apply exactly as before, so every
+	// existing project keeps byte-identical behavior and nobody's token spend
+	// moves because a table value was corrected. With one, the Claude per-request
+	// cap and the history budget scale off the window, so raising it genuinely
+	// sends more history instead of being absorbed by a hardcoded ceiling.
+	// Both derive from contextBasedBudget (pre-Claude-cap) so the two platforms
+	// scale symmetrically rather than the Claude cap compounding the ratio down.
+	var scaled = !!(options.serviceId && getProjectContextWindow(options.serviceId));
+	var claudeInputCap = scaled
+		? Math.max(CLAUDE_PER_REQUEST_INPUT_CAP, Math.round(contextBasedBudget * CLAUDE_INPUT_CAP_RATIO))
+		: CLAUDE_PER_REQUEST_INPUT_CAP;
 	var availableInputBudget = options.platform === 'claude'
-		? Math.min(contextBasedBudget, CLAUDE_PER_REQUEST_INPUT_CAP) : contextBasedBudget;
+		? Math.min(contextBasedBudget, claudeInputCap) : contextBasedBudget;
 	var systemCost = estimateTextTokens(options.systemPrompt) + 12;
-	var budgetForHistory = Math.max(1000, Math.min(HISTORY_TOKEN_BUDGET, availableInputBudget - systemCost));
-	var windowed = options.history.slice(-MAX_HISTORY_MESSAGES);
+	var historyAllowance = scaled
+		? Math.max(HISTORY_TOKEN_BUDGET, Math.round(contextBasedBudget * HISTORY_BUDGET_RATIO))
+		: HISTORY_TOKEN_BUDGET;
+	var budgetForHistory = Math.max(1000, Math.min(historyAllowance, availableInputBudget - systemCost));
+	// The message count scales alongside the token budget; otherwise 20 messages
+	// is a second ceiling that swallows the extra budget on a raised window.
+	var maxHistoryMessages = scaled
+		? Math.max(MAX_HISTORY_MESSAGES, Math.round(MAX_HISTORY_MESSAGES * (budgetForHistory / HISTORY_TOKEN_BUDGET)))
+		: MAX_HISTORY_MESSAGES;
+	var windowed = options.history.slice(-maxHistoryMessages);
 	var latestIndex = windowed.length - 1;
 	var trimmed = windowed.map(function (m, i) {
 		if (i === latestIndex) return m;

package/src/engine/download_encoding.ts

@@ -0,0 +1,281 @@
+/**
+ * How a text file the chat offers as a download is encoded and labelled, so that
+ * whatever opens it reads the characters correctly, in any language.
+ *
+ * When the model answers with a fenced ```name.ext block, the client turns that
+ * block into a Blob and an <a download>. We always write UTF-8, but several very
+ * common consumers do not assume UTF-8 when nothing in the file says so, and fall
+ * back to the reader's local ANSI codepage: CP949 in Korea, CP932 in Japan,
+ * CP936/CP950 in China and Taiwan, CP1251 for Cyrillic. The file is valid and
+ * every non-ASCII character still opens as mojibake.
+ *
+ * There is no single fix, because the way a file declares "this is UTF-8" is a
+ * property of the FORMAT:
+ *
+ *   - a spreadsheet (csv/tsv) and a Windows text editor read a BOM;
+ *   - HTML is opened from disk with no HTTP headers, so only an in-document
+ *     <meta charset> survives;
+ *   - XML carries its encoding in its declaration, and a WRONG declaration makes
+ *     a conforming parser fail outright;
+ *   - RTF is 7-bit, so non-ASCII has to be escaped into \uNNNN?;
+ *   - JSON, JSONL and YAML are UTF-8 by specification, and a BOM BREAKS them.
+ *
+ * Anything unrecognised is left byte-for-byte alone: an unknown extension is far
+ * more likely to be machine-parsed, where an uninvited BOM is a new bug, than to
+ * be opened by a legacy editor.
+ *
+ * MIRROR of skapi-mcp/download-encoding.js, which does the same job for files the
+ * server publishes (writeReport / exportRecordsToFile). A file the user gets from
+ * a fenced block and the same file published as a download must behave
+ * identically, so the two have to change together.
+ */
+
+export const BOM = '';
+
+/** Files a spreadsheet or a Windows text editor opens directly. */
+export const BOM_EXTS = new Set(['csv', 'tsv', 'tab', 'txt', 'text', 'log']);
+
+/** Read from disk with no HTTP headers, so the declaration must be in the file. */
+export const HTML_EXTS = new Set(['html', 'htm', 'xhtml']);
+export const XML_EXTS = new Set(['xml', 'svg', 'rss', 'atom', 'xsl', 'xslt', 'plist', 'kml']);
+export const RTF_EXTS = new Set(['rtf']);
+
+/** Content types by extension. Every text family carries an explicit charset. */
+export const EXT_CONTENT_TYPES: Record<string, string> = {
+	csv: 'text/csv; charset=utf-8',
+	tsv: 'text/tab-separated-values; charset=utf-8',
+	tab: 'text/tab-separated-values; charset=utf-8',
+	txt: 'text/plain; charset=utf-8',
+	text: 'text/plain; charset=utf-8',
+	log: 'text/plain; charset=utf-8',
+	md: 'text/markdown; charset=utf-8',
+	markdown: 'text/markdown; charset=utf-8',
+	json: 'application/json; charset=utf-8',
+	jsonl: 'application/x-ndjson; charset=utf-8',
+	ndjson: 'application/x-ndjson; charset=utf-8',
+	geojson: 'application/geo+json; charset=utf-8',
+	yaml: 'text/yaml; charset=utf-8',
+	yml: 'text/yaml; charset=utf-8',
+	toml: 'text/plain; charset=utf-8',
+	ini: 'text/plain; charset=utf-8',
+	sql: 'text/plain; charset=utf-8',
+	html: 'text/html; charset=utf-8',
+	htm: 'text/html; charset=utf-8',
+	xhtml: 'application/xhtml+xml; charset=utf-8',
+	xml: 'application/xml; charset=utf-8',
+	svg: 'image/svg+xml; charset=utf-8',
+	css: 'text/css; charset=utf-8',
+	js: 'text/javascript; charset=utf-8',
+	ts: 'text/plain; charset=utf-8',
+	py: 'text/x-python; charset=utf-8',
+	sh: 'text/x-shellscript; charset=utf-8',
+	srt: 'application/x-subrip; charset=utf-8',
+	vtt: 'text/vtt; charset=utf-8',
+	ics: 'text/calendar; charset=utf-8',
+	vcf: 'text/vcard; charset=utf-8',
+	// RTF is 7-bit ASCII by specification, so it takes no charset parameter.
+	rtf: 'application/rtf',
+	// Binary types the model can only ever REFERENCE, never author in a fence, but
+	// which keep the type sensible if one ever shows up.
+	pdf: 'application/pdf',
+	png: 'image/png',
+	jpg: 'image/jpeg',
+	jpeg: 'image/jpeg',
+	gif: 'image/gif',
+	webp: 'image/webp',
+};
+
+export type EncodingClass = 'bom' | 'html' | 'xml' | 'rtf' | 'none';
+
+export function normalizeExt(ext: string | null | undefined): string {
+	return String(ext || '').trim().replace(/^\./, '').toLowerCase();
+}
+
+/** Extension of a filename, '' when it has none. */
+export function extOf(filename: string | null | undefined): string {
+	const name = String(filename || '');
+	const dot = name.lastIndexOf('.');
+	return dot > 0 ? normalizeExt(name.slice(dot + 1)) : '';
+}
+
+/** Which encoding declaration this format understands. */
+export function encodingClassForExt(ext: string | null | undefined): EncodingClass {
+	const e = normalizeExt(ext);
+	if (BOM_EXTS.has(e)) return 'bom';
+	if (HTML_EXTS.has(e)) return 'html';
+	if (XML_EXTS.has(e)) return 'xml';
+	if (RTF_EXTS.has(e)) return 'rtf';
+	return 'none';
+}
+
+/** True when a file with this extension must be written BOM-first. */
+export function needsBomForExt(ext: string | null | undefined): boolean {
+	return encodingClassForExt(ext) === 'bom';
+}
+
+/**
+ * Content type to declare. Everything textual carries an explicit charset:
+ * without one the receiving end guesses, and it guesses the local codepage.
+ */
+export function contentTypeForExt(
+	ext: string | null | undefined,
+	fallback = 'text/plain; charset=utf-8',
+): string {
+	return EXT_CONTENT_TYPES[normalizeExt(ext)] || fallback;
+}
+
+export function hasBom(text: string): boolean {
+	return typeof text === 'string' && text.charCodeAt(0) === 0xfeff;
+}
+
+// --- HTML -------------------------------------------------------------------
+// Only the document head is inspected. A charset written further down is not one
+// a browser would act on anyway (the spec only honours a declaration in the first
+// 1024 bytes), and scanning the whole body would start matching <meta> tags that
+// a document about HTML is merely quoting.
+export const HTML_HEAD_WINDOW = 4096;
+const META_CHARSET_RE = /<meta[^>]+charset\s*=\s*["']?\s*([a-z0-9_-]+)/i;
+const META_HTTP_EQUIV_RE = /<meta[^>]+http-equiv\s*=\s*["']?content-type["']?[^>]*>/i;
+
+/**
+ * Make an HTML document state its own encoding. Downloaded HTML is opened from
+ * disk, where the Content-Type we set no longer exists, so a document with no
+ * <meta charset> is decoded with the browser's locale default.
+ */
+export function ensureHtmlCharset(text: string): string {
+	const src = String(text == null ? '' : text);
+	const head = src.slice(0, HTML_HEAD_WINDOW);
+
+	const declared = META_CHARSET_RE.exec(head);
+	if (declared) {
+		// A declaration naming anything other than UTF-8 is actively wrong: the
+		// bytes underneath it are always UTF-8. Correct it in place rather than
+		// adding a second, contradictory one.
+		if (declared[1].toLowerCase().replace(/[^a-z0-9]/g, '') === 'utf8') return src;
+		const start = declared.index + declared[0].length - declared[1].length;
+		return src.slice(0, start) + 'utf-8' + src.slice(start + declared[1].length);
+	}
+	// An http-equiv Content-Type with no charset= is still a declaration the
+	// browser will use; replace the whole tag with the modern short form.
+	const httpEquiv = META_HTTP_EQUIV_RE.exec(head);
+	if (httpEquiv) {
+		return src.slice(0, httpEquiv.index)
+			+ '<meta charset="utf-8">'
+			+ src.slice(httpEquiv.index + httpEquiv[0].length);
+	}
+
+	const tag = '<meta charset="utf-8">';
+	// As early as the document allows: inside <head> if there is one, else right
+	// after <html>, else at the very top (a fragment is still parsed head-first).
+	const headOpen = /<head[^>]*>/i.exec(head);
+	if (headOpen) {
+		const at = headOpen.index + headOpen[0].length;
+		return src.slice(0, at) + '\n' + tag + src.slice(at);
+	}
+	const htmlOpen = /<html[^>]*>/i.exec(head);
+	if (htmlOpen) {
+		const at = htmlOpen.index + htmlOpen[0].length;
+		return src.slice(0, at) + '\n<head>' + tag + '</head>' + src.slice(at);
+	}
+	const doctype = /<!doctype[^>]*>/i.exec(head);
+	if (doctype) {
+		const at = doctype.index + doctype[0].length;
+		return src.slice(0, at) + '\n' + tag + src.slice(at);
+	}
+	return tag + '\n' + src;
+}
+
+// --- XML ---------------------------------------------------------------------
+const XML_DECL_RE = /^\s*<\?xml\s[^?]*\?>/i;
+
+/**
+ * Correct an XML declaration that names the wrong encoding.
+ *
+ * A MISSING declaration is left alone on purpose: XML with none is UTF-8 by
+ * specification, so every conforming parser already gets it right. A declaration
+ * naming EUC-KR over UTF-8 bytes, on the other hand, makes a parser fail outright.
+ */
+export function ensureXmlEncoding(text: string): string {
+	const src = String(text == null ? '' : text);
+	const decl = XML_DECL_RE.exec(src);
+	if (!decl) return src;
+
+	const found = /encoding\s*=\s*["']([^"']*)["']/i.exec(decl[0]);
+	if (!found) return src; // declaration without an encoding is UTF-8 by spec
+	if (found[1].toLowerCase().replace(/[^a-z0-9]/g, '') === 'utf8') return src;
+
+	const fixedDecl = decl[0].slice(0, found.index)
+		+ found[0].replace(found[1], 'UTF-8')
+		+ decl[0].slice(found.index + found[0].length);
+	return fixedDecl + src.slice(decl[0].length);
+}
+
+// --- RTF ----------------------------------------------------------------------
+const RTF_SIGNATURE_RE = /^[\s]*\{\\rtf/i;
+
+/** True when the body really is RTF rather than text merely named .rtf. */
+export function looksLikeRtf(text: string): boolean {
+	return RTF_SIGNATURE_RE.test(String(text == null ? '' : text));
+}
+
+/**
+ * Escape every non-ASCII character into RTF's \uNNNN? form.
+ *
+ * RTF is 7-bit: a literal UTF-8 byte in the body is read through the codepage the
+ * header declares, which is how Korean, Japanese and Cyrillic RTF turns to
+ * mojibake in Word. \uNNNN? is codepage-independent.
+ *
+ * ASCII is never touched, which matters: backslashes and braces in an RTF body
+ * are control syntax, and "escaping" them would destroy the document. \u takes a
+ * SIGNED 16-bit value, so anything above 0x7FFF is emitted negative, and astral
+ * characters are emitted as their two surrogates.
+ */
+export function escapeRtfNonAscii(text: string): string {
+	const src = String(text == null ? '' : text);
+	let out = '';
+	let plainFrom = 0;
+	for (let i = 0; i < src.length; i++) {
+		const code = src.charCodeAt(i); // UTF-16 unit: surrogates arrive separately
+		if (code < 0x80) continue;
+		out += src.slice(plainFrom, i);
+		out += `\\u${code > 32767 ? code - 65536 : code}?`;
+		plainFrom = i + 1;
+	}
+	return plainFrom === 0 ? src : out + src.slice(plainFrom);
+}
+
+/** Apply the format's encoding declaration to a whole document. */
+export function applyEncodingDeclaration(text: string, ext: string | null | undefined): string {
+	const src = String(text == null ? '' : text);
+	switch (encodingClassForExt(ext)) {
+		case 'bom':
+			// Never a second BOM: two U+FEFF show as a visible  in the first cell.
+			return hasBom(src) ? src : BOM + src;
+		case 'html':
+			return ensureHtmlCharset(src);
+		case 'xml':
+			return ensureXmlEncoding(src);
+		case 'rtf':
+			// Text merely NAMED .rtf is opened by Word as plain text, where a BOM is
+			// what makes it read UTF-8. Escaping it would show literal \u escapes.
+			return looksLikeRtf(src) ? escapeRtfNonAscii(src) : (hasBom(src) ? src : BOM + src);
+		default:
+			return src;
+	}
+}
+
+/**
+ * Everything a client needs to turn a fenced ```name.ext block into a download:
+ * the exact text to put in the Blob and the type to give it.
+ */
+export function prepareDownloadText(
+	filename: string,
+	body: string,
+): { ext: string; text: string; contentType: string } {
+	const ext = extOf(filename);
+	return {
+		ext,
+		text: applyEncodingDeclaration(body, ext),
+		contentType: contentTypeForExt(ext),
+	};
+}

package/src/engine/errors.ts

@@ -3,6 +3,23 @@
  * agent.vue / bunnyquery chatbox so both consumers share one implementation.
  */
 
+// Plain-language text per upstream status, for the case below where the provider
+// gave us no readable message of its own.
+var STATUS_MESSAGE: { [code: string]: string } = {
+	'408': 'The AI provider timed out before it started.',
+	'409': 'The AI provider rejected the request as conflicting.',
+	'413': 'The request was too large for the AI provider.',
+	'429': 'The AI provider is rate limiting requests right now.',
+	'500': 'The AI provider hit an internal error.',
+	'502': 'The AI provider is temporarily unreachable.',
+	'503': 'The AI provider is temporarily unavailable.',
+	'504': 'The AI provider timed out.',
+};
+
+function isTransientStatus(status: number): boolean {
+	return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+
 export function getErrorMessage(input: any): string {
 	if (!input) return 'Something went wrong.';
 	if (typeof input === 'string') return input;
@@ -10,6 +27,23 @@ export function getErrorMessage(input: any): string {
 	if (input.body && input.body.error && input.body.error.message) return input.body.error.message;
 	if (input.body && typeof input.body.message === 'string') return input.body.message;
 	if (input.message) return input.message;
+
+	// Every branch above assumes the provider answered with JSON. It does not
+	// always: a gateway failure in front of the model API (Cloudflare's "502 Bad
+	// gateway" page, an ALB error page) arrives as an HTML STRING in `body`, so
+	// `body.error` / `body.message` are undefined on it and the user used to get a
+	// bare 'Something went wrong.' with no way to tell a provider outage from a
+	// bug in their own data. The status code is the one thing we always have, so
+	// say what it means and whether retrying is worth it.
+	var status = typeof input.status_code === 'number' ? input.status_code
+		: typeof input.status === 'number' ? input.status : 0;
+	if (status) {
+		var text = STATUS_MESSAGE[String(status)]
+			|| (status >= 500 ? 'The AI provider returned a server error.'
+				: 'The AI provider rejected the request.');
+		return text + ' (error ' + status + ')'
+			+ (isTransientStatus(status) ? ' This is usually temporary, please try again.' : '');
+	}
 	return 'Something went wrong.';
 }
 

package/src/engine/history.ts

@@ -40,6 +40,46 @@ export function extractLastUserTextFromRequest(requestBody: any): string {
 	return '';
 }
 
+/** The two openings an indexing prompt can have. A bg-queue item that starts with
+ *  neither is an ordinary chat that happened to be routed onto that queue. */
+export function isIndexingRequestText(userText: any): boolean {
+	if (typeof userText !== 'string') return false;
+	return userText.indexOf('A new file has just been uploaded') === 0 || userText.indexOf('CONTINUE indexing') === 0;
+}
+
+export type IndexingRequestRef = {
+	name: string;
+	path?: string;
+	mime?: string;
+	size?: number;
+	/** A CONTINUE pass rather than the run's first. */
+	continued: boolean;
+};
+
+/**
+ * The file an indexing prompt is about, read back out of the prompt itself.
+ *
+ * The prompt is the only description of the pass that survives on the server, so
+ * this is how BOTH a history rebuild and a worker-minted pass the client never
+ * dispatched (ChatSession._adoptWorkerIndexingPasses) recover the file. Shared so
+ * the two produce the same `_indexFile`, which is what makes them group together.
+ */
+export function parseIndexingRequestText(userText: any): IndexingRequestRef | null {
+	if (typeof userText !== 'string' || !userText) return null;
+	var nameMatch = userText.match(/^- name: (.+)$/m);
+	if (!nameMatch) return null;
+	var mimeMatch = userText.match(/^- mime type: (.+)$/m);
+	var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
+	var pathMatch = userText.match(/^- storage path: (.+)$/m);
+	return {
+		name: nameMatch[1].trim(),
+		path: pathMatch ? pathMatch[1].trim() : undefined,
+		mime: mimeMatch ? mimeMatch[1].trim() : undefined,
+		size: sizeMatch ? Number(sizeMatch[1]) : undefined,
+		continued: userText.indexOf('CONTINUE indexing') === 0,
+	};
+}
+
 export type MapHistoryOptions = {
 	clearedAt: number;
 	serviceId: string;
@@ -78,31 +118,21 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			// alongside the formatted label so grouping never has to parse it back.
 			var indexFile: any = undefined;
 			if (item._isBgTask) {
-				var nameMatch = userText.match(/^- name: (.+)$/m);
-				if (nameMatch) {
-					var mimeMatch = userText.match(/^- mime type: (.+)$/m);
-					var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
-					var pathMatch = userText.match(/^- storage path: (.+)$/m);
+				var ref = parseIndexingRequestText(userText);
+				if (ref) {
 					// A CONTINUE pass ("CONTINUE indexing …") gets the compact
 					// continuation label; a first pass ("A new file …") gets the full
 					// one. Mirrors agent.vue's mapHistoryListToMessages so a big file's
 					// windows read as progress, not the same task repeating.
-					var isContinuePass = userText.indexOf('CONTINUE indexing') === 0;
 					displayContent = opts.formatIndexingLabel(
-						nameMatch[1].trim(),
-						mimeMatch ? mimeMatch[1].trim() : '',
-						sizeMatch ? Number(sizeMatch[1]) : null,
-						pathMatch ? pathMatch[1].trim() : undefined,
+						ref.name,
+						ref.mime || '',
+						typeof ref.size === 'number' ? ref.size : null,
+						ref.path,
 						false,
-						isContinuePass
+						ref.continued
 					);
-					indexFile = {
-						name: nameMatch[1].trim(),
-						path: pathMatch ? pathMatch[1].trim() : undefined,
-						mime: mimeMatch ? mimeMatch[1].trim() : undefined,
-						size: sizeMatch ? Number(sizeMatch[1]) : undefined,
-						continued: isContinuePass,
-					};
+					indexFile = ref;
 				} else {
 					displayContent = userText;
 				}