bunnyquery 1.6.0 → 1.7.0

package/src/engine/requests.ts

@@ -10,9 +10,9 @@
  *                                    state that stays in the consumer, not here;
  *                                    only the BgTaskEntry TYPE lives here)
  */
-import { buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingContinueMessage, buildIndexingRenderMessage } from './prompts';
-import { isServerExtractable, isPagedReadFile, isImageVisionFile, makeExtractPlaceholder, makeRenderPlaceholder, RENDER_PAGES_PER_WINDOW, type ExtractDirective, type FileUrlDirective } from './office';
-import { chatEngineConfig, pollOpt } from './config';
+import { buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingContinueMessage, buildIndexingRenderMessage, buildIndexingRenderContinueTemplate, buildIndexingWindowMessage } from './prompts';
+import { isServerExtractable, isPagedReadFile, isImageVisionFile, isWindowedReadFile, makeExtractPlaceholder, makeRenderPlaceholder, makeWindowPlaceholder, RENDER_PAGES_PER_WINDOW, type ExtractDirective, type FileUrlDirective } from './office';
+import { chatEngineConfig, pollOpt, windowedIndexingEnabled } from './config';
 
 export const ANTHROPIC_MESSAGES_API_URL = 'https://api.anthropic.com/v1/messages';
 const ANTHROPIC_MODELS_API_URL = 'https://api.anthropic.com/v1/models';
@@ -33,30 +33,52 @@ const OPENAI_WEB_SEARCH_EXTERNAL_WEB_ACCESS = true;
 export const MCP_NAME = 'BunnyQuery';
 
 export const DEFAULT_CLAUDE_MODEL = 'claude-sonnet-4-6';
-export const DEFAULT_OPENAI_MODEL = 'gpt-5.4';
+export const DEFAULT_OPENAI_MODEL = 'gpt-5.6-luna';
 
 const mcpUrl = () => chatEngineConfig().mcpBaseUrl;
 const clientSecretRequest = (opts: any) => chatEngineConfig().clientSecretRequest(opts);
 
+// Resolve the per-image `detail` for OpenAI. The version match tolerates a
+// trailing variant/date suffix (`gpt-5.4-nano`, `-mini`, `-2026-01-01`, …):
+// previously the pattern was anchored with no suffix allowed, so EVERY suffixed
+// model silently fell through to 'auto' — i.e. the cheap tiers that most need
+// resolution were the ones getting downsampled images.
+//
+// Base models keep their exact previous behavior ('original'). A suffixed
+// variant resolves to 'high' rather than 'original': 'high' is the universally
+// supported value, and we have no way to confirm a given variant accepts
+// 'original' — sending an unsupported value would fail the whole request, which
+// is far worse than a slightly less detailed image.
 const getOpenAIImageDetail = (model?: string) => {
 	const normalized = (model || DEFAULT_OPENAI_MODEL).trim().toLowerCase();
-	const match = normalized.match(/^gpt-(\d+)(?:\.(\d+))?$/);
+	const match = normalized.match(/^gpt-(\d+)(?:\.(\d+))?(-[a-z0-9.\-]+)?$/);
 	if (!match) {
 		return DEFAULT_OPENAI_IMAGE_DETAIL;
 	}
 
 	const major = Number(match[1]);
 	const minor = match[2] === undefined ? null : Number(match[2]);
+	const isVariant = !!match[3];
 
-	if (major > 5) {
-		return 'original';
+	const supportsOriginal = major > 5 || (major === 5 && minor !== null && minor >= 4);
+	if (!supportsOriginal) {
+		return DEFAULT_OPENAI_IMAGE_DETAIL;
 	}
 
-	if (major === 5 && minor !== null && minor >= 4) {
-		return 'original';
-	}
+	return isVariant ? 'high' : 'original';
+};
 
-	return DEFAULT_OPENAI_IMAGE_DETAIL;
+// Per-image `detail` for WORKER-RENDERED document pages (the `_skapi_render`
+// path). Same resolution as above with one difference: these are dense scans
+// whose entire purpose is to be read, so 'auto' is never acceptable — it lets
+// the API downsample exactly the pixels the model needs to OCR. Floor it at
+// 'high'; models that support full-resolution 'original' still get it.
+//
+// Without this the worker falls back to its own model-blind default ('high'),
+// which silently denies the strongest models the 'original' detail they support.
+const getRenderImageDetail = (model?: string) => {
+	const detail = getOpenAIImageDetail(model);
+	return detail === DEFAULT_OPENAI_IMAGE_DETAIL ? 'high' : detail;
 };
 
 export type ClaudeRole = 'user' | 'assistant';
@@ -478,20 +500,66 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 	const visionFile = !parsedContent && isImageVisionFile(attachment.name, attachment.mime);
 	const renderFrom = Math.max(0, info.renderFrom || 0);
 	const renderPlaceholder = visionFile ? makeRenderPlaceholder(attachment.storagePath) : undefined;
+	// Tell the worker what image `detail` to stamp on the injected page blocks.
+	// The worker is model-blind, so without this it applies a one-size default and
+	// the strongest models never get the 'original' detail they support. Only
+	// meaningful for OpenAI — Claude has no per-image detail knob and the worker
+	// ignores the field for it.
+	const renderDetail = platform === 'openai'
+		? getRenderImageDetail(info.model || DEFAULT_OPENAI_MODEL)
+		: undefined;
+	// `auto_continue` + `continue_text` hand the page loop to the WORKER: when its renderer
+	// reports pages left after this window, it builds the next pass from this template
+	// (substituting the window's 1-based start page for RENDER_FROM_TOKEN) and enqueues it
+	// itself. That is what makes a 500-page document index end-to-end — the loop no longer
+	// depends on the tab staying open, nor on the model correctly declaring itself unfinished.
 	const skapiRender = visionFile && renderPlaceholder
 		? {
 			_skapi_render: [
-				{ path: attachment.storagePath, from: renderFrom, count: RENDER_PAGES_PER_WINDOW, placeholder: renderPlaceholder, name: attachment.name, mime: attachment.mime },
+				{
+					path: attachment.storagePath, from: renderFrom, count: RENDER_PAGES_PER_WINDOW,
+					placeholder: renderPlaceholder, name: attachment.name, mime: attachment.mime, detail: renderDetail,
+					auto_continue: true,
+					continue_text: buildIndexingRenderContinueTemplate(attachment, renderPlaceholder),
+				},
+			],
+		}
+		: {};
+
+	// SERVER-DRIVEN windowed read. When enabled, the worker reads one window of the file
+	// per request and continues from the reader's own cursor until the file is exhausted,
+	// so the traversal no longer lives inside the model's turn budget.
+	//
+	// Flag-gated because the BACKEND MUST SHIP FIRST: against a worker that does not strip
+	// `_skapi_window`, the directive reaches the provider as an unknown body field and the
+	// call fails terminally with no retry.
+	const windowedRead =
+		!visionFile && !parsedContent && windowedIndexingEnabled() &&
+		isWindowedReadFile(attachment.name, attachment.mime);
+	const windowPlaceholder = windowedRead ? makeWindowPlaceholder(attachment.storagePath) : undefined;
+	const skapiWindow = windowedRead && windowPlaceholder
+		? {
+			_skapi_window: [
+				{
+					path: attachment.storagePath,
+					cursor: null,
+					placeholder: windowPlaceholder,
+					name: attachment.name,
+					mime: attachment.mime,
+					kind: 'window',
+					auto_continue: true,
+					continue_text: buildIndexingWindowMessage(attachment, windowPlaceholder, true),
+				},
 			],
 		}
 		: {};
 
 	// Spreadsheets are read by PAGING through readFileContent (grid rows), NOT inlined - so
 	// they skip the inline server-extract and the agent is told to page the whole file.
-	const pagedRead = !visionFile && (continuing || (!parsedContent && isPagedReadFile(attachment.name, attachment.mime)));
+	const pagedRead = !visionFile && !windowedRead && (continuing || (!parsedContent && isPagedReadFile(attachment.name, attachment.mime)));
 
 	// Client-parsed content wins over server-side extraction.
-	const serverExtract = !visionFile && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
+	const serverExtract = !visionFile && !windowedRead && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
 	const placeholder = serverExtract ? makeExtractPlaceholder(attachment.storagePath) : undefined;
 	const extractContent: ExtractDirective[] | undefined =
 		serverExtract && placeholder
@@ -502,6 +570,8 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 
 	const userMessage = (visionFile && renderPlaceholder)
 		? buildIndexingRenderMessage(attachment, renderPlaceholder, renderFrom)
+		: (windowedRead && windowPlaceholder)
+		? buildIndexingWindowMessage(attachment, windowPlaceholder, false)
 		: continuing
 			? buildIndexingContinueMessage(attachment)
 			: buildIndexingUserMessage(
@@ -541,6 +611,7 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 				max_output_tokens: MAX_TOKENS,
 				...skapiExtract,
 				...skapiRender,
+				...skapiWindow,
 				input: [
 					{ role: 'system', content: systemPrompt },
 					{
@@ -589,6 +660,7 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 			max_tokens: MAX_TOKENS,
 			...skapiExtract,
 			...skapiRender,
+			...skapiWindow,
 			system: [
 				{
 					type: 'text',
@@ -713,6 +785,23 @@ export async function listOpenAIModels(service: string, owner: string) {
 // so the chat-history BETWEEN query never includes bg-queue items. '-' (45) works.
 export const BG_INDEXING_QUEUE_SUFFIX = '-bg';
 
+/**
+ * True when a request belongs to the background-indexing queue.
+ *
+ * Accepts BOTH shapes this value arrives in: the bare queue name the client sends
+ * ("<userId>-bg"), and the server qid that comes back on history/poll responses
+ * ("<service>:<queue>|<seq>"). Testing the tail of the raw value only works for the
+ * first: a qid ends in "|<seq>", so `endsWith('-bg')` is always false for it — which
+ * silently meant history items were NEVER recognised as background tasks.
+ */
+export function isBgIndexingQueue(queueName?: string): boolean {
+	if (typeof queueName !== 'string' || !queueName) return false;
+	const prefix = queueName.split('|')[0];
+	const idx = prefix.lastIndexOf(':');
+	const name = idx === -1 ? prefix : prefix.slice(idx + 1);
+	return name.slice(-BG_INDEXING_QUEUE_SUFFIX.length) === BG_INDEXING_QUEUE_SUFFIX;
+}
+
 // Pending background-indexing task descriptor. NOTE: the live mutable queue
 // (a Vue `reactive([])` in agent.vue, a plain array in bunnyquery) is app-level
 // state owned by the consumer — only the TYPE lives in the engine.
@@ -733,18 +822,16 @@ export type BgTaskEntry = {
 
 // Token the indexing agent appends to its final message ONLY when it has fully read and
 // saved the whole file. Its ABSENCE is what tells the client to run another CONTINUE pass.
+//
+// Applies to the TEXT/GRID paging path only. The vision path (rendered PDF pages) no longer
+// asks the model whether it is finished — the worker advances that loop off the renderer's
+// page count — so this marker has no say in whether a PDF keeps going.
 export const INDEXING_COMPLETE_MARKER = 'INDEXING_COMPLETE';
 // Cap on CONTINUE passes per file, so a file the agent can never mark complete (or a
 // pathological loop) stops instead of re-dispatching forever. The text/grid paging path
 // reads MANY windows within a single pass (the agent loops readFileContent in one turn), so
 // a small cap suffices.
 export const MAX_INDEXING_RESUME_PASSES = 6;
-// The VISION path (rendered PDF pages) can only advance ONE page-window per pass, because the
-// worker injects a single window of images into each request. A big scanned PDF therefore
-// needs one pass PER window (pages / RENDER_PAGES_PER_WINDOW), so it gets a much higher cap.
-// The loop still terminates naturally when the agent reaches the last window (it appends
-// INDEXING_COMPLETE); this cap is only the backstop for a doc larger than it covers.
-export const MAX_VISION_RESUME_PASSES = 40;
 
 export async function getChatHistory(
 	params: { service?: string; owner?: string; platform: 'claude' | 'openai'; queue?: string },