bunnyquery 1.3.2 → 1.3.5

package/package.json

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

package/src/engine/errors.ts

@@ -34,6 +34,55 @@ export function isErrorResponseBody(response: any): boolean {
 	return false;
 }
 
+// A request that failed because the REQUEST ITSELF is malformed — an unknown or
+// rejected parameter on a 400/422 — will deterministically re-fail if resent
+// unchanged; no session refresh or retry can fix it. Detecting it lets the retry
+// gates refuse to auto-resend (otherwise a 400 whose param name merely contains
+// "token", e.g. `max_output_tokens`, trips the `invalid_request + token` branch
+// of isAuthExpiredError below and loops refresh->resend forever, burning tokens).
+// This is the `_skapi_extract` 400 class. Distinct from auth-expiry, which IS
+// retryable after a token refresh — so 401 (auth) and 429/5xx (transient) are
+// intentionally NOT treated as non-retryable here.
+export function isNonRetryableRequestError(input: any): boolean {
+	if (!input || typeof input !== 'object') return false;
+
+	var status = typeof input.status_code === 'number' ? input.status_code
+		: typeof input.status === 'number' ? input.status : undefined;
+
+	// Collect the error envelope wherever it lives (response, response.body, or a
+	// thrown error), mirroring isErrorResponseBody / isAuthExpiredError.
+	var param: any = undefined;
+	var blobs: string[] = [];
+	var sources = [input.error, input.body && input.body.error, input.body, input];
+	for (var i = 0; i < sources.length; i++) {
+		var e = sources[i];
+		if (!e) continue;
+		if (typeof e === 'string') { blobs.push(e); continue; }
+		if (typeof e !== 'object') continue;
+		if (param === undefined && e.param != null) param = e.param;
+		if (typeof e.code === 'string') blobs.push(e.code);
+		if (typeof e.type === 'string') blobs.push(e.type);
+		if (typeof e.message === 'string') blobs.push(e.message);
+	}
+	var hay = blobs.join(' | ').toLowerCase();
+
+	// Explicit "unknown / unsupported parameter" is always a malformed request.
+	if (hay.indexOf('unknown_parameter') !== -1 || hay.indexOf('unknown parameter') !== -1 ||
+		hay.indexOf('unsupported_parameter') !== -1 || hay.indexOf('unsupported parameter') !== -1) {
+		return true;
+	}
+
+	// A 400/422 invalid_request that points at a specific rejected field: resending
+	// the identical body re-fails. (401 -> isAuthExpiredError; 429/5xx -> transient.)
+	var isClientReqStatus = status === 400 || status === 422;
+	if (isClientReqStatus && param != null && param !== '') return true;
+	if (isClientReqStatus && hay.indexOf('invalid_request') !== -1 &&
+		(hay.indexOf('parameter') !== -1 || hay.indexOf('param') !== -1)) {
+		return true;
+	}
+	return false;
+}
+
 export function isAuthExpiredError(input: any): boolean {
 	if (!input) return false;
 	var blobs: string[] = [];

package/src/engine/index.ts

@@ -30,7 +30,7 @@ export * from './prompts';
 
 // Pure helpers (Tier-1.5): error detection, token budgeting, link/path
 // normalization, and history mapping — shared so both consumers stay identical.
-export { getErrorMessage, isErrorResponseBody, isAuthExpiredError } from './errors';
+export { getErrorMessage, isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError } from './errors';
 export * from './budget';
 export * from './links';
 export {

package/src/engine/session.ts

@@ -30,7 +30,7 @@ import {
 	OPENAI_RESPONSES_API_URL,
 	type BgTaskEntry,
 } from './requests';
-import { isErrorResponseBody, isAuthExpiredError, getErrorMessage } from './errors';
+import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, getErrorMessage } from './errors';
 import { buildBoundedChatMessages } from './budget';
 import { createInlineLinkRegex } from './links';
 import { mapHistoryListToMessages, extractLastUserTextFromRequest } from './history';
@@ -116,11 +116,15 @@ export class ChatSession {
 		};
 		var run = sendAndPoll()
 			.catch(function (err: any) {
-				if (isAuthExpiredError(err)) return self.host.refreshSession().then(sendAndPoll);
+				// Only auth-expiry is worth a refresh+resend; a malformed-request 400
+				// (e.g. the `_skapi_extract`/unknown-parameter class) re-fails identically,
+				// so never loop on it — guard against isAuthExpiredError's heuristic
+				// misfiring on a param name that merely contains "token".
+				if (isAuthExpiredError(err) && !isNonRetryableRequestError(err)) return self.host.refreshSession().then(sendAndPoll);
 				throw err;
 			})
 			.then(function (response: any) {
-				if (isErrorResponseBody(response) && isAuthExpiredError(response)) {
+				if (isErrorResponseBody(response) && isAuthExpiredError(response) && !isNonRetryableRequestError(response)) {
 					return self.host.refreshSession().then(sendAndPoll);
 				}
 				return response;
@@ -348,6 +352,7 @@ export class ChatSession {
 				this.host.notify(); this.enqueueTypewrite(aiIdx, answer, lid);
 			}
 		}
+		this._removeStrayPendingAssistants();
 		this.promoteNextQueuedToRunning();
 		this.updateHistoryCache();
 		this.host.notify();
@@ -382,12 +387,14 @@ export class ChatSession {
 				if (thPos2 !== -1) this.state.messages.splice(thPos2, 1);
 			}
 			if (serverId) this.cancelledServerIds.delete(serverId);
+			this._removeStrayPendingAssistants();
 			this.promoteNextQueuedToRunning(); this.updateHistoryCache(); this.host.notify(); this.host.scrollToBottom(true);
 			return;
 		}
 		var targetIdx = this.resolveQueuedUserBubble(serverId);
 		if (targetIdx === undefined) { this.host.notify(); this.updateHistoryCache(); return; }
 		this.insertAtTarget({ role: 'assistant', content: getErrorMessage(err), isError: true }, targetIdx);
+		this._removeStrayPendingAssistants();
 		this.promoteNextQueuedToRunning(); this.updateHistoryCache(); this.host.notify(); this.host.scrollToBottom(true);
 	}
 
@@ -512,17 +519,52 @@ export class ChatSession {
 		if (pendingIdx === -1) return Promise.resolve();
 		if (latest.isError || !latest.content) {
 			this.state.messages[pendingIdx] = { role: 'assistant', content: latest.content || '', isError: !!latest.isError };
+			this._removeStrayPendingAssistants();
 			this.host.notify();
 			this.promoteNextQueuedToRunning();
 			return Promise.resolve();
 		}
 		var lid = this._newLocalId();
 		this.state.messages[pendingIdx] = { role: 'assistant', content: '', isPending: false, _localId: lid };
+		this._removeStrayPendingAssistants();
 		this.host.notify();
 		this.promoteNextQueuedToRunning();
 		return this.enqueueTypewrite(pendingIdx, latest.content, lid);
 	}
 
+	// Remove any leftover non-background pending ("Thinking…") assistant bubbles.
+	// There is normally at most ONE such bubble at a time (promoteNext* refuses to
+	// add a second), so any extra is a duplicate — it appears when a concurrent
+	// history refetch re-maps the still-"running" turn into a pending placeholder
+	// (with a real _serverItemId) while the local pending bubble (no _serverItemId)
+	// is rescued and re-appended (see loadHistory rescue below). Each resolve path
+	// only replaces the FIRST pending bubble, so without this a stray "Thinking…"
+	// survives next to the reply/error. MUST run AFTER the resolved bubble has been
+	// made non-pending and BEFORE promoteNext*() (so a freshly-promoted Thinking,
+	// which is added only once no pending assistant remains, is preserved).
+	_removeStrayPendingAssistants(): void {
+		for (var k = this.state.messages.length - 1; k >= 0; k--) {
+			var m = this.state.messages[k];
+			if (m.isPending && m.role === 'assistant' && !m.isBackgroundTask) this.state.messages.splice(k, 1);
+		}
+	}
+
+	// Drop the pending flags on the resolved turn's USER bubble (preserving its
+	// content + background-task marker). Needed because a bg "Indexing:" turn's user
+	// bubble carries isPendingInProcess; leaving it set keeps the bubble visually
+	// stuck and keeps its bgTaskQueue entry alive forever.
+	_clearPendingUserBubble(itemId: string): void {
+		var uIdx = this.state.messages.findIndex(function (m) {
+			return m.role === 'user' && m._serverItemId === itemId &&
+				(m.isPendingInProcess || m.isPendingQueued || m.isSendingToServer);
+		});
+		if (uIdx === -1) return;
+		var u = this.state.messages[uIdx];
+		var cleaned: ChatMessage = { role: 'user', content: u.content, _serverItemId: itemId };
+		if (u.isBackgroundTask) cleaned.isBackgroundTask = true;
+		this.state.messages[uIdx] = cleaned;
+	}
+
 	// If an immediate-send request for the current cache key is still in flight
 	// (e.g. the view unmounted then remounted mid-request), show the sending
 	// state, await it, then render the reply from the cache. Skipped when the
@@ -557,6 +599,11 @@ export class ChatSession {
 			: ((platform === 'openai' ? extractOpenAIText(response) : extractClaudeText(response)) || '').trim();
 		var idx = this.state.messages.findIndex(function (m) { return m.isPending && m._serverItemId === itemId; });
 		if (idx !== -1) {
+			// A bg "Indexing:" turn pushes a user bubble (isPendingInProcess) ALONGSIDE
+			// the assistant Thinking; replacing only the assistant leaves that user
+			// bubble stuck pending — and drainBgTaskQueue then never clears its queue
+			// entry (its stillPending check stays true). Un-pend it here too.
+			this._clearPendingUserBubble(itemId);
 			if (isErr) {
 				this.state.messages[idx] = { role: 'assistant', content: answer, isError: true, _serverItemId: itemId };
 				this.host.notify(); this.updateHistoryCache(); return;
@@ -656,7 +703,7 @@ export class ChatSession {
 		var fetchHistory = function () { return getChatHistory({ service: serviceId, owner: owner, platform: platform }, options); };
 
 		return Promise.resolve().then(fetchHistory).catch(function (err: any) {
-			if (isAuthExpiredError(err)) return self.host.refreshSession().then(fetchHistory);
+			if (isAuthExpiredError(err) && !isNonRetryableRequestError(err)) return self.host.refreshSession().then(fetchHistory);
 			throw err;
 		}).then(function (history: any) {
 			if (token !== self.state.gateRefreshToken) return;
@@ -686,12 +733,23 @@ export class ChatSession {
 				mapped.forEach(function (m: any) { if (m._serverItemId) serverIds[m._serverItemId] = 1; });
 				var locallyCancelled: any = {};
 				self.state.messages.forEach(function (m) { if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = 1; });
+				// If the freshly-mapped server list ALREADY shows this in-flight turn
+				// as a pending placeholder (a non-bg pending assistant, which carries
+				// a real _serverItemId), re-pushing the local no-_serverItemId
+				// user+Thinking would DUPLICATE it. Each resolve path only clears the
+				// first pending bubble, so the duplicate strands a "Thinking…" beside
+				// the reply/error. There is at most one in-flight regular turn, so a
+				// mapped pending assistant IS this turn — skip the redundant local copy.
+				var mappedHasPendingAssistant = mapped.some(function (m: any) {
+					return m.isPending && m.role === 'assistant' && !m.isBackgroundTask;
+				});
 				var rescued: ChatMessage[] = [];
 				for (var ri = 0; ri < self.state.messages.length; ri++) {
 					var mm = self.state.messages[ri];
 					if (mm.isBackgroundTask) continue;
 					if (mm._serverItemId && serverIds[mm._serverItemId]) continue;
 					if (!mm._serverItemId) {
+						if (mappedHasPendingAssistant) continue;
 						if (mm.isSendingToServer || mm.isPendingQueued || mm.isPendingInProcess || mm.isPending) rescued.push(mm);
 						else if (self.state.sending && mm.role === 'user') {
 							var next = self.state.messages[ri + 1];