bunnyquery 1.8.2 → 1.8.4

package/package.json

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

package/src/engine/budget.ts

@@ -1,7 +1,7 @@
 /**
  * Token-budgeting (pure). Moved verbatim from the chatbox. Constants are shared
  * module-level values (identical in both consumers); a config knob is premature.
- * buildBoundedChatMessages now takes `serviceId` in its options so it can pass it
+ * buildBoundedChatMessages now takes `projectId` in its options so it can pass it
  * to sanitizeAttachmentLinksForHistory (which used to read a global).
  */
 import { sanitizeAttachmentLinksForHistory } from './links';
@@ -52,16 +52,16 @@ export function registerModelContextWindows(models: Array<{ id?: string; max_inp
 /** 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();
+export function setProjectContextWindow(projectId: string, tokens: number | null | undefined): void {
+	var key = (projectId || '').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();
+export function getProjectContextWindow(projectId: string): number | null {
+	var key = (projectId || '').trim();
 	return key && projectContextWindows[key] ? projectContextWindows[key] : null;
 }
 export var OUTPUT_TOKEN_RESERVE = 22000;
@@ -99,8 +99,8 @@ export function estimateMessageTokens(msg: { role: string; content: string }): n
  * 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;
+export function getContextWindow(platform: string, model?: string, projectId?: string): number {
+	var override = projectId ? getProjectContextWindow(projectId) : null;
 	if (override) return override;
 
 	var normalized = (model || '').trim().toLowerCase();
@@ -128,11 +128,11 @@ export type BoundedChatOptions = {
 	systemPrompt: string;
 	history: Array<{ role: string; content: string }>;
 	/** Used to strip/rewrite expired attachment links in older user turns. */
-	serviceId: string;
+	projectId: string;
 };
 
 export function buildBoundedChatMessages(options: BoundedChatOptions) {
-	var contextWindow = getContextWindow(options.platform, options.model, options.serviceId);
+	var contextWindow = getContextWindow(options.platform, options.model, options.projectId);
 	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
@@ -143,7 +143,7 @@ export function buildBoundedChatMessages(options: BoundedChatOptions) {
 	// 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 scaled = !!(options.projectId && getProjectContextWindow(options.projectId));
 	var claudeInputCap = scaled
 		? Math.max(CLAUDE_PER_REQUEST_INPUT_CAP, Math.round(contextBasedBudget * CLAUDE_INPUT_CAP_RATIO))
 		: CLAUDE_PER_REQUEST_INPUT_CAP;
@@ -167,7 +167,7 @@ export function buildBoundedChatMessages(options: BoundedChatOptions) {
 		// Sanitize BOTH roles: user turns via the "Attached files:" block, assistant
 		// turns via the safe db-only path (forAssistant=true) so a volatile db url the
 		// model emitted doesn't get replayed into the LLM context as a dead link.
-		var sanitized = sanitizeAttachmentLinksForHistory(stripped, options.serviceId, m.role !== 'user');
+		var sanitized = sanitizeAttachmentLinksForHistory(stripped, options.projectId, m.role !== 'user');
 		return Object.assign({}, m, { content: sanitized });
 	});
 	var bounded: Array<{ role: string; content: string }> = [], used = 0;

package/src/engine/history.ts

@@ -2,9 +2,9 @@
  * History mapping (pure). Moved verbatim from the chatbox. The clear-horizon
  * timestamp and the "Indexing: …" display label are INJECTED (clearedAt param,
  * formatIndexingLabel callback) so the engine touches neither localStorage nor
- * view-specific display formatting. serviceId is passed for link sanitization.
+ * view-specific display formatting. projectId is passed for link sanitization.
  */
-import { extractClaudeText, extractOpenAIText } from './requests';
+import { extractClaudeText, extractOpenAIText, INDEXING_COMPLETE_MARKER, EMPTY_INDEXING_REPLY } from './requests';
 import { isErrorResponseBody, getErrorMessage } from './errors';
 import { sanitizeAttachmentLinksForHistory } from './links';
 
@@ -82,7 +82,7 @@ export function parseIndexingRequestText(userText: any): IndexingRequestRef | nu
 
 export type MapHistoryOptions = {
 	clearedAt: number;
-	serviceId: string;
+	projectId: string;
 	/** View-side display formatter for "Indexing:/Reindexing: …" bubbles. */
 	formatIndexingLabel: (name: string, mime?: string, size?: number | null, storagePath?: string, reindex?: boolean, continued?: boolean) => string;
 };
@@ -103,6 +103,18 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 		var userText = extractLastUserTextFromRequest(requestBody);
 		var assistantText = isPending ? '' : ((extractAssistantText(response) || '').trim() || '');
 		var isErrorResponse = !isPending && (isFailed || isErrorResponseBody(response));
+		// Record the completion marker, then STRIP it — both, and in that order.
+		// Recording gives the display layer a structured signal instead of a substring
+		// search over model prose. Stripping matches the live resolution path: without
+		// it the literal token rendered inside the bubble on every history load, which
+		// is not a post-reload curiosity — a first-page load REPLACES the live bubbles,
+		// and those responses are now on screen far more often than they used to be.
+		//
+		// Gated on _isBgTask: only an INDEXING pass has a protocol token to hide. An
+		// ordinary reply that merely mentions it keeps its own words.
+		var reportedComplete = !!(item && item._isBgTask) && !isErrorResponse && !!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 : undefined;
 		// A USER bubble shows when the request was made (`created`); an ASSISTANT
 		// bubble shows when its response landed (`updated`). Fall back to the other
@@ -137,7 +149,7 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 					displayContent = userText;
 				}
 			} else {
-				displayContent = sanitizeAttachmentLinksForHistory(userText, opts.serviceId);
+				displayContent = sanitizeAttachmentLinksForHistory(userText, opts.projectId);
 			}
 			var userMsg: any = { role: 'user', content: displayContent };
 			if (isInProcess) userMsg.isPendingInProcess = true;
@@ -163,13 +175,18 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			if (serverItemId !== undefined) em._serverItemId = serverItemId;
 			if (replyTs !== undefined) em._ts = replyTs;
 			mapped.push(em);
-		} else if (assistantText) {
+		// `|| reportedComplete`: a pass whose ENTIRE answer was the completion token
+		// strips down to an empty string, and the plain `assistantText` guard then
+		// emitted no bubble at all — while the live path emitted one. The run read as
+		// finished live and unfinished after a reload, so the row's loader came back.
+		} else if (assistantText || reportedComplete) {
 			// Safe db-only sanitize (forAssistant) so a volatile db url the model
 			// emitted renders as a re-mintable `_expired_.url` link, not a dead one.
-			var okm: any = { role: 'assistant', content: sanitizeAttachmentLinksForHistory(assistantText, opts.serviceId, true) };
+			var okm: any = { role: 'assistant', content: sanitizeAttachmentLinksForHistory(assistantText, opts.projectId, true) || EMPTY_INDEXING_REPLY };
 			if (item._isBgTask) okm.isBackgroundTask = true;
 			if (serverItemId !== undefined) okm._serverItemId = serverItemId;
 			if (replyTs !== undefined) okm._ts = replyTs;
+			if (reportedComplete) okm._indexComplete = true;
 			mapped.push(okm);
 		}
 	});

package/src/engine/host.ts

@@ -8,9 +8,17 @@
  */
 
 export interface ChatIdentity {
-	serviceId: string;
+	projectId: string;
+	/**
+	 * The PUBLIC project ID: the formatted two-segment token (skapi.project_id).
+	 * projectId above is the RAW regional code the wire endpoints take; the public
+	 * token is what MCP tools accept and what prompts must show the model, since the
+	 * model copies it verbatim into tool calls. Optional for older hosts; prompts
+	 * fall back to the raw code when absent.
+	 */
+	publicProjectId?: string;
 	owner: string;
-	/** Per-user queue name (falls back to serviceId). */
+	/** Per-user queue name (falls back to projectId). */
 	userId: string;
 	platform: 'claude' | 'openai' | 'none';
 	model?: string;
@@ -28,6 +36,11 @@ export interface ChatIdentity {
 export interface PinnedDispatchContext {
 	identity: ChatIdentity;
 	systemPrompt: string;
+	/** Id returned by stageOutgoingMessage. The turn's bubble is already on
+	 *  screen (staged while its attachments upload), so dispatchComposedMessage
+	 *  REPLACES that bubble in place instead of pushing a second one at the
+	 *  bottom — the message keeps the position it was sent in. */
+	stageId?: string;
 }
 
 /**
@@ -56,13 +69,50 @@ export interface ChatMessage {
 	isPendingInProcess?: boolean;
 	isPendingQueued?: boolean;
 	isPendingOlder?: boolean;
+	/** PROTOCOL flag: true from the moment a queued turn is dispatched until the
+	 *  server acknowledges it. It is the token the ack's findIndex matches on, so
+	 *  nothing may clear it early. It is NOT a style input — see _dimSending. */
 	isSendingToServer?: boolean;
+	/** PRESENTATIONAL flag: render this bubble dimmed because the turn has not been
+	 *  handed over yet. Split from isSendingToServer because an ATTACHMENT turn is
+	 *  un-dimmed the instant its files finish indexing, while the request itself is
+	 *  still un-acked for another moment; dropping isSendingToServer to achieve that
+	 *  would cost the turn its _serverItemId (the ack matches on that flag alone, and
+	 *  a _useBgQueue turn is excluded from every fallback that would recover it). */
+	_dimSending?: boolean;
 	isCancelled?: boolean;
 	isError?: boolean;
 	isBackgroundTask?: boolean;
 	/** Set on background-indexing REQUEST bubbles only (see IndexingFileRef). */
 	_indexFile?: IndexingFileRef;
+	/** Set on a background-indexing RESPONSE bubble whose raw answer carried the
+	 *  INDEXING_COMPLETE marker. Stamped before the marker is stripped for display,
+	 *  in every path that builds one (live resolution and both history mappers), so
+	 *  a run reads the same before and after a reload.
+	 *
+	 *  Meaningful ONLY for a client-driven chain, where it is the very signal
+	 *  maybeResumeIndexing stops on. The worker-driven paths (PDF vision, windowed
+	 *  reads) advance off the renderer's page count and their prompt deliberately
+	 *  never asks for the marker, so a model that emits one there is guessing —
+	 *  which is how an 88-page file once "finished" at page 15. */
+	_indexComplete?: boolean;
 	_useBgQueue?: boolean;
+	/** Local id of a turn STAGED at Send time while its attachments upload. The
+	 *  bubble exists before any server request does, so it is never matched by
+	 *  _serverItemId and is never promoted/cancelled by the queue machinery —
+	 *  dispatchComposedMessage consumes it (pinned.stageId) when the turn is
+	 *  finally sent. Staged bubbles are deliberately kept OUT of the history
+	 *  cache: an unmount kills the upload that would resolve them, so a cached
+	 *  copy would replay as a bubble that uploads forever. */
+	_stageId?: string;
+	/** Staged-turn phase 1: its files are still uploading. Renders
+	 *  "(Uploading files...)", dimmed. */
+	isUploadingAttachments?: boolean;
+	/** Staged-turn phase 2: the files are up and the turn is waiting for the whole
+	 *  background-indexing chain behind them to finish. Renders "(Indexing files...)",
+	 *  still dimmed. Cleared (with _dimSending) by markStagedMessageReady the moment
+	 *  the queue drains, which is when the turn genuinely becomes "(In queue)". */
+	isAwaitingIndexing?: boolean;
 	_serverItemId?: string;
 	_localId?: string;
 	_cancelling?: boolean;
@@ -73,7 +123,7 @@ export interface ChatMessage {
 	 *  it is created, then reconciled to the server value on the next history load.
 	 *  Absent while a turn is still pending, so no time shows on a "Thinking" bubble. */
 	_ts?: number;
-	// History cache key (`serviceId#platform`) this bubble was created under.
+	// History cache key (`projectId#platform`) this bubble was created under.
 	// Stamped on LOCALLY-created bubbles only (the optimistic user message and
 	// its "Thinking..." placeholder); server-mapped bubbles are identified by
 	// _serverItemId instead. The dashboard renders every project through ONE
@@ -97,6 +147,24 @@ export interface ChatState {
 	historyStartKeyHistory: string[];
 	historyRequestToken: number;
 	gateRefreshToken: number;
+	/** Files the SERVER still has unresolved indexing work for, by the key a
+	 *  collapsed row uses (storage path, else filename). Lives on the state rather
+	 *  than privately so a reactive consumer re-renders when it changes. */
+	liveIndexKeys: { [fileKey: string]: boolean };
+	/** Whether `liveIndexKeys` has been answered at least once for this chat. False
+	 *  means "we have not found out", which the display layer reads as still
+	 *  working — never as an all-clear. */
+	liveIndexChecked: boolean;
+	/** Server item ids of the indexing passes that existed — on the row, or on the
+	 *  bg queue — when the user STOPPED that file. Two readers, one fact:
+	 *  buildChatDisplayList reports the run as stopped when it holds any of them
+	 *  (a stop routinely leaves no other trace), and _applyIndexCancellations
+	 *  refuses to let one of them lift the stop the way a genuinely new indexing
+	 *  request does. Ids, not file keys: they name the RUN that was stopped, so a
+	 *  later re-index of the same file cannot inherit it. On the state, like
+	 *  liveIndexKeys, so a reactive consumer re-renders the moment a stop is
+	 *  recorded — a stop with nothing left to cancel changes no message at all. */
+	stoppedIndexIds: { [serverItemId: string]: boolean };
 }
 
 export interface ChatHost {
@@ -155,6 +223,12 @@ export interface ChatHost {
 	 *  through to a plain re-index. Implementations must be best-effort (swallow
 	 *  "not found" / permission errors so indexing still proceeds). */
 	deleteExistingFileRecord?(storagePath: string): Promise<any>;
+	/**
+	 * Create the file's "src::<storagePath>" record before indexing starts, so every pass has a
+	 * reference target that exists. Optional: a host without it keeps the old behaviour, where
+	 * whichever pass got there first created the record and the others hoped it had.
+	 */
+	ensureFileIndexRecord?(storagePath: string, meta?: { name?: string; mime?: string; size?: number }): Promise<any>;
 	/** Map a relative path to the consumer's db storage key (e.g. uid-prefixed). */
 	storagePathFor(relPath: string): string;
 	getMimeType(name: string): string | null;

package/src/engine/index.ts

@@ -49,6 +49,8 @@ export * from './budget';
 // block and a server-published file open identically in Excel, Word and a browser.
 export * from './download_encoding';
 export * from './links';
+export * from './link_markup';
+export * from './image_preview';
 export * from './time';
 export * from './ai_agent';
 export {
@@ -97,7 +99,11 @@ export {
 export {
 	// constants
 	POLL_INTERVAL,
+	MAX_CONCURRENT_BG_POLLS,
+	getVisionProfile,
+	type VisionProfile,
 	BG_INDEXING_QUEUE_SUFFIX,
+	bgIndexingQueueName,
 	isBgIndexingQueue,
 	MCP_NAME,
 	DEFAULT_CLAUDE_MODEL,
@@ -116,6 +122,13 @@ export {
 	// content transforms
 	transformContentWithImages,
 	transformContentWithOpenAIImages,
+	// The token an indexing pass ends on when it has read the whole file. Exported
+	// because agent.vue's FORKED history mapper has to record-then-strip it exactly
+	// as the engine's own mapper does, or a run reads differently in the two clients.
+	INDEXING_COMPLETE_MARKER,
+	// Stand-in text for a pass whose whole answer was that token; both mappers need
+	// it so a run reads the same live and after a reload.
+	EMPTY_INDEXING_REPLY,
 	// types
 	type ClaudeRole,
 	type ClaudeMessage,