bunnyquery 1.8.6 → 1.8.9

package/dist/engine.d.mts

@@ -95,6 +95,57 @@ interface ChatEngineConfig {
      * until the worker is deployed, then flip it per environment.
      */
     windowedIndexing?: boolean;
+    /**
+     * Mint the durable "indexing finished" marker record ("done::<path>",
+     * reference "src::<path>", table __INDEXING__ — same shape the backend
+     * worker writes via /internal/index-complete) for runs whose completion
+     * THIS CLIENT knows deterministically: a single-pass file's settled pass,
+     * or a client-driven chain whose reply carried the completion token.
+     * Worker-driven chains are NOT minted from the client (their completion is
+     * only ever inferred here); the worker writes their marker itself.
+     * Must be best-effort: tolerate the marker already existing and never
+     * throw. Optional so older consumers keep the pre-marker inference.
+     */
+    mintIndexDoneMarker?: (info: {
+        service: string;
+        storagePath: string;
+    }) => void;
+    /**
+     * Create-or-update the per-file indexing RUN record ("run::<path>",
+     * reference "src::<path>", table __INDEXING__). The record is the durable
+     * "a run exists and this is its status" signal that lets chat rows and
+     * files-page badges paint without scanning bg history.
+     *
+     * The consumer implements upsert semantics (the records API has none):
+     * create, and on "is already taken" look the record up by unique_id and
+     * re-post with its record_id, merging `patch` over the stored data.
+     * Status precedence is the consumer's job too: 'working' must NEVER
+     * overwrite a terminal status (done/error/cancelled) — a late create from
+     * a slow enqueue must not resurrect a run another writer already closed.
+     * Must be best-effort and never throw. Optional: without it the engine
+     * behaves exactly as before (legacy scan/probe path).
+     */
+    upsertIndexRunRecord?: (info: {
+        service: string;
+        storagePath: string;
+        patch: {
+            status: 'working' | 'done' | 'error' | 'cancelled';
+            filename?: string;
+            started?: number;
+            finished?: number;
+            error?: string;
+            queue?: string;
+        };
+    }) => void;
+    /**
+     * Single-item csr-poll point lookup (skapi.util.request('csr-poll', {id,
+     * service, owner}, {auth:true})). For a RESOLVED item the backend returns
+     * the provider response body itself; for a failed one, the resolved error.
+     * Used by ChatSession.hydrateCompactItems to fetch the real bodies of
+     * compact history stubs when the user expands an indexing row. Optional:
+     * without it, stubs keep their server-extracted heads.
+     */
+    csrHistoryItemLookup?: (fullId: string, service: string, owner: string) => Promise<any>;
 }
 declare function configureChatEngine(config: ChatEngineConfig): void;
 declare function chatEngineConfig(): ChatEngineConfig;
@@ -149,7 +200,26 @@ declare function composeUserMessage(text: string, attachmentUrls: Array<{
     name: string;
     url: string;
     storagePath?: string;
-}>): ComposedUserMessage;
+}>, opts?: {
+    /**
+     * Inline each server-extractable attachment's whole text into the
+     * prompt (the `_skapi_extract` directives + BEGIN/END FILE CONTENT
+     * block). Default true, which is right when the file's content is
+     * nowhere else yet.
+     *
+     * Pass FALSE when the turn is dispatched AFTER the file's indexing run
+     * has drained. Extraction is the same server-side download+parse the
+     * indexing pass already performed, so inlining repeats it: the worker
+     * fetches and re-parses every attachment a second time (which reads,
+     * from the outside, exactly like the file being indexed again), and the
+     * whole file text is re-sent as prompt tokens. It is also the WORSE
+     * copy for anything large, because inline extraction truncates at
+     * MAX_EXTRACTED_CHARS while the indexed records cover the file end to
+     * end. The model reaches the content through the records
+     * (getRecords with reference "src::<path>") or readFileContent.
+     */
+    inlineExtractedContent?: boolean;
+}): ComposedUserMessage;
 
 /**
  * Attachment helpers shared by every consumer's view layer.
@@ -309,26 +379,56 @@ declare function getErrorMessage(input: any): string;
 declare function isErrorResponseBody(response: any): boolean;
 declare function isNonRetryableRequestError(input: any): boolean;
 declare function isAuthExpiredError(input: any): boolean;
+/**
+ * True when the AI PROVIDER rejected the project's own API key.
+ *
+ * Deliberately narrow, and deliberately NOT the same question as
+ * isAuthExpiredError: that one is about OUR session/MCP bearer going stale,
+ * which the client fixes by refreshing and resending. This one means the key
+ * the project owner pasted is wrong or revoked, which only a human can fix.
+ *
+ * A bare 401 is NOT enough to conclude it (the MCP bearer expiring is also a
+ * 401), so this matches only the provider's key-specific markers:
+ *   Anthropic -> `authentication_error`, "invalid x-api-key"
+ *   OpenAI    -> `invalid_api_key`, "Incorrect API key provided"
+ * Accepts a response object, a thrown error, or the message string those get
+ * reduced to by getErrorMessage, because the view usually only keeps the text.
+ */
+declare function isProviderApiKeyError(input: any): boolean;
 
 declare var CONTEXT_WINDOW_DEFAULT: Record<string, number>;
 declare var CONTEXT_WINDOW_BY_MODEL: Record<string, number>;
+declare var MAX_OUTPUT_BY_MODEL: Record<string, number>;
+declare var DEFAULT_CONTEXT_WINDOW: 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.
+ * Record context windows and output caps from a provider models listing. Reads
+ * `max_input_tokens` and `max_tokens` (Anthropic); items without them are
+ * skipped, so passing an OpenAI listing is a no-op rather than an error.
+ *
+ * Note the asymmetry against the static table: Anthropic reports
+ * `max_input_tokens` (input only) where CONTEXT_WINDOW_BY_MODEL holds totals, so
+ * a registered Claude window is treated as a total and loses its output cap
+ * worth of budget. That is deliberate — under-spending the window is safe, and
+ * with no compaction beta enabled overrunning it is a hard error.
  */
 declare function registerModelContextWindows(models: Array<{
     id?: string;
     max_input_tokens?: number;
+    max_tokens?: number;
 }> | null | undefined): void;
 declare function setProjectContextWindow(projectId: string, tokens: number | null | undefined): void;
 declare function getProjectContextWindow(projectId: string): number | null;
+declare var MAX_OUTPUT_TOKENS: number;
 declare var OUTPUT_TOKEN_RESERVE: number;
 declare var TOOL_AND_RESPONSE_BUFFER: number;
 declare var MIN_INPUT_TOKEN_BUDGET: number;
+declare var MIN_PER_REQUEST_INPUT_CAP: number;
+/** @deprecated renamed to {@link MIN_PER_REQUEST_INPUT_CAP} (no longer Claude-only). */
 declare var CLAUDE_PER_REQUEST_INPUT_CAP: number;
 declare var MAX_HISTORY_MESSAGES: number;
 declare var HISTORY_TOKEN_BUDGET: number;
+declare var INPUT_CAP_RATIO: number;
+/** @deprecated renamed to {@link INPUT_CAP_RATIO} (no longer Claude-only). */
 declare var CLAUDE_INPUT_CAP_RATIO: number;
 declare var HISTORY_BUDGET_RATIO: number;
 declare function estimateTextTokens(text: string): number;
@@ -336,20 +436,21 @@ declare function estimateMessageTokens(msg: {
     role: string;
     content: string;
 }): number;
+declare function getModelContextWindow(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.
+ * How many output tokens to ask for. We never want more than MAX_OUTPUT_TOKENS,
+ * but a model whose own cap is lower rejects the request outright, so clamp to
+ * whichever is smaller. Models with no known cap keep MAX_OUTPUT_TOKENS.
+ */
+declare function getMaxOutputTokens(platform: string, model?: string): number;
+/**
+ * The window a request is actually budgeted at: the per-project override when
+ * one is set, otherwise DEFAULT_CONTEXT_WINDOW. Both are clamped to the model's
+ * hard ceiling, because a budget above the ceiling builds a request the provider
+ * rejects, and a stored override outlives the model it was chosen under.
  */
 declare function getContextWindow(platform: string, model?: string, projectId?: string): number;
+declare function getInputTokenBudget(platform: string, model?: string, projectId?: string): number;
 declare function stripFileBlocksFromHistory(content: string): string;
 type BoundedChatOptions = {
     platform: string;
@@ -488,6 +589,23 @@ declare var LINK_LABEL_MAX_DISPLAY_CHARS: number;
  * not, which is precisely the kind of divergence a shared constant exists to stop.
  */
 declare var EXPIRED_LINK_REFRESH_EXPIRES_SECONDS: number;
+/**
+ * Lifetime of the url minted for an inline image PREVIEW.
+ *
+ * Longer than the click url above, and for a different reason. A click hands the
+ * user a url they may keep, so it stays short. A preview url is consumed by the
+ * page itself and never leaves it, and it is the ONE lever on how long the
+ * downloaded picture stays reusable: get_signed_url will not cache a mint for
+ * longer than the credential inside it survives, so `browser_cache` cannot buy
+ * local availability that `expires` has not paid for. Twenty minutes meant every
+ * image re-downloaded three times an hour of ordinary reading.
+ *
+ * An hour, giving 55 minutes of cache once the server's five minute headroom is
+ * taken off. Short enough that a leaked preview url is not a standing grant, long
+ * enough that a conversation does not re-fetch its own pictures while the user is
+ * still reading it.
+ */
+declare var PREVIEW_URL_EXPIRES_SECONDS: number;
 /**
  * Seconds the browser may reuse a minted preview url (`browser_cache`).
  *
@@ -497,12 +615,17 @@ declare var EXPIRED_LINK_REFRESH_EXPIRES_SECONDS: number;
  * url comes back out of the browser cache, so the body already on disk stays
  * addressable.
  *
- * Deliberately far longer than EXPIRED_LINK_REFRESH_EXPIRES_SECONDS above, and
- * that is the whole trick: the url is short-lived while the file stays available
- * locally for a WEEK. What keeps an image painting is the cached BODY, not a live
- * url. Once the browser evicts that body it refetches with a url that has since
- * expired, gets a 403, and the error path re-mints with `refresh`. That path is
- * therefore load-bearing, not a rare fallback.
+ * A CEILING, not a promise. get_signed_url caps what it grants at the lifetime of
+ * the url inside the response (expires minus headroom, so 15 minutes for the
+ * platform's 20 minute url), because a mint cached for longer than its own
+ * credential is a guaranteed 403 that the browser keeps serving from its own
+ * store. Asking for the week is still right: it says what this client would
+ * reuse if the url were stable by construction, and the server decides.
+ *
+ * What keeps an image painting is the cached BODY, not a live url. Once the
+ * browser evicts that body it refetches with a url that has since expired, gets a
+ * 403, and the error path re-mints with `refresh` and mintCacheBustStamp. That
+ * path is load-bearing, not a rare fallback.
  *
  * A week is the platform default for reading a private file, not a number chosen
  * here: skapi-js reads every private record file with
@@ -525,6 +648,69 @@ declare var PREVIEW_BROWSER_CACHE_SECONDS: number;
  * dead url with no way to notice; deriving it makes that unrepresentable.
  */
 declare var LINK_REFRESH_WINDOW_MS: number;
+/**
+ * Cache generation for the mint request url. BUMP THIS to abandon every mint
+ * response browsers are currently holding.
+ *
+ * Generation 2 retires the entries written before 2026-08-11. Those were stored
+ * with `max-age=604800` around a presign that dies in twenty minutes, so from
+ * minute 21 each one is a guaranteed 403 that the browser keeps serving from its
+ * own store for the rest of the week. The server no longer grants a lifetime a
+ * url cannot back (get_signed_url resolve_browser_cache), but that fixes what is
+ * written from now on and cannot reach what is already stored on a user's
+ * device. Changing the url is the only thing that can: an entry nobody requests
+ * again is an entry that cannot answer again.
+ */
+declare var MINT_CACHE_GENERATION: number;
+/**
+ * Window stamp for a REFRESH mint.
+ *
+ * WINDOWED, not Date.now(): a per-call stamp is a new cache key per image per
+ * retry, which is what made the original `nocache` parameter worse than the
+ * disease. One stamp per refresh window means every repair inside those minutes
+ * shares a single entry, and it rotates before the url it carries can die.
+ */
+declare function mintCacheBustStamp(now?: number): number;
+/**
+ * The `nocache` value for a preview mint: the generation, plus a window stamp
+ * when this mint is a repair.
+ *
+ * A repair MUST reach the origin, and the request header the clients used to
+ * rely on cannot do it. `Cache-Control: no-cache` is not a CORS-safelisted
+ * request header, and the record gateway's preflight answers
+ * `Access-Control-Allow-Headers` WITHOUT it (verified against the live api on
+ * 2026-08-11), so a mint carrying that header is rejected by the browser before
+ * it is ever sent. Every repair therefore failed, in every browser, and the chip
+ * went straight to "(unavailable)". Only a phone noticed, because only a phone
+ * drops image bodies often enough to need the repair at all.
+ *
+ * A query parameter has no such problem: it is part of the url, so it needs no
+ * preflight and no cooperation from the cache.
+ */
+declare function previewMintCacheToken(refresh?: boolean): string;
+/**
+ * How long before a presign dies we stop handing it out.
+ *
+ * A url served with one second left is a 403 with extra steps: the request still
+ * has to reach S3, and an image body still has to start arriving.
+ */
+declare var PRESIGN_SAFETY_MARGIN_MS: number;
+/**
+ * When the url in hand actually dies, read out of the url itself, or null if it
+ * carries no expiry we recognise.
+ *
+ * Every client-side cache here ages a url from the moment it ARRIVED, which is
+ * only the same thing as its lifetime when the mint went to the network. Once
+ * mint responses are cacheable that assumption breaks: a mint answered from the
+ * browser's store can be nearly as old as its own max-age, and the client then
+ * adds its own reuse window on top, so a 20 minute credential can be handed to an
+ * <img> half an hour after it was signed. Asking the url when it dies removes the
+ * stacking instead of trying to budget for it.
+ *
+ * Both signature versions, because the platform mints SigV2 through the host
+ * bucket and SigV4 elsewhere.
+ */
+declare function presignExpiryEpochMs(url: string): number | null;
 declare function createInlineLinkRegex(): RegExp;
 declare function safeDecodeURIComponent(v: string): string;
 declare function encodePathSegments(path: string): string;
@@ -681,6 +867,17 @@ declare function classifyInlineLink(full: string, groups: Array<string | undefin
  */
 declare function linkUnavailableKeyForPath(remotePath: string): string;
 declare function linkUnavailableKeyForHref(href: string): string;
+/**
+ * Every key a stored file can be marked under, given only its path.
+ *
+ * Marking writes ONE key (whichever identifier the failing call had) and the
+ * lookup ORs all of them, which is fine in one direction and wrong in the other:
+ * a view that later learns the file is reachable knows only the path, and
+ * clearing `path:` alone leaves a chip greyed by a failed CLICK (which marks
+ * `href:` too) exactly as dead as before. The placeholder href is derived from
+ * the path, so both keys can be rebuilt from it.
+ */
+declare function linkUnavailableKeysForPath(remotePath: string): string[];
 declare function isLinkUnavailable(link: {
     href?: string;
     expiredHref?: string;
@@ -889,153 +1086,6 @@ type ParsedAiAgent = {
 declare function parseAiAgentValue(value: string | null | undefined): ParsedAiAgent;
 declare function buildAiAgentValue(platform: string | null | undefined, model?: string | null, contextWindow?: number | null): string;
 
-declare function filterListByClearHorizon(list: any[], clearedAt: number): any[];
-declare function normalizeTextContent(content: any): string;
-declare function extractLastUserTextFromRequest(requestBody: any): string;
-/** 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. */
-declare function isIndexingRequestText(userText: any): boolean;
-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.
- */
-declare function parseIndexingRequestText(userText: any): IndexingRequestRef | null;
-type MapHistoryOptions = {
-    clearedAt: number;
-    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;
-};
-declare function mapHistoryListToMessages(list: any[], platform: 'claude' | 'openai', opts: MapHistoryOptions): {
-    messages: any[];
-    runningItemIds: string[];
-};
-
-/**
- * Keep older history REACHABLE by paging until the message box actually gains
- * something to scroll to.
- *
- * Older history is paged in by one trigger only: the user scrolling to the top
- * of the message box. That trigger has two ways to die, and collapsed indexing
- * rows cause both:
- *
- *   1. The box never scrolls. A file's every indexing pass (the first plus every
- *      CONTINUE pass, request AND response bubble each) folds into ONE row, so a
- *      full history page — twenty-plus messages — can render as a single line.
- *      Content shorter than the viewport fires no scroll event, so page 2 is
- *      never requested and any conversation the user had before that upload is
- *      permanently out of reach.
- *   2. The fetched page adds no height. A page that is entirely the same file's
- *      earlier passes joins the collapsed row already on screen and renders
- *      nothing new. The user, sitting at scrollTop 0, scrolls up again — and
- *      because the position never changed, no further scroll event fires.
- *
- * Both are the same shape: fetch, re-measure, and keep going until the user
- * genuinely gained reachable content, history ran out, or the pager stopped
- * advancing. `isSatisfied` is what differs between the two (can the box scroll
- * at all / did it grow), so the loop below takes it as a predicate.
- *
- * DOM-free like the rest of the engine — the caller supplies the measurement and
- * awaits its own render before measuring, so agent.vue and the widget run the
- * identical loop over their own pagers.
- */
-/** Overflow (px) that counts as "the user can scroll here". Comfortably more
- *  than the 60px top threshold that triggers the next page, so a filled box has
- *  real room to scroll rather than sitting one pixel from the trigger. */
-declare const HISTORY_FILL_SLACK_PX = 64;
-/** Pages one fill pass will request before giving up. Reached only by a chat
- *  whose history really is dozens of pages of one file's indexing passes; the
- *  cap exists so a pager that stops advancing can never spin forever. */
-declare const MAX_HISTORY_FILL_PAGES = 24;
-type FillHistoryViewportOptions = {
-    /** The user has reachable content and paging can stop. Called AFTER the
-     *  caller's own render has settled (nextTick / rAF), since only the caller
-     *  knows when its view has painted — hence the allowance for a promise. */
-    isSatisfied: () => boolean | Promise<boolean>;
-    /** All history is loaded — nothing left to page in. */
-    isEndOfList: () => boolean;
-    /** A history request is already in flight. Waited out, not treated as a stop
-     *  condition: a background first-page refresh (the queue-detect tick fires one
-     *  every couple of seconds while a file is indexing) would otherwise swallow
-     *  the user's scroll-up entirely, and scrolling up again from scrollTop 0
-     *  produces no second event to retry with. */
-    isLoading: () => boolean;
-    /** Messages currently loaded. Used to detect a page that added nothing, which
-     *  means the pager is not advancing and looping would never terminate. */
-    messageCount: () => number;
-    /** Fetch ONE older page (the caller's own fetchMore path, scroll-restore and
-     *  all). Return `false` when the request was NOT issued (the caller's own
-     *  single-flight guard swallowed it) so the loop retries instead of reading
-     *  the unchanged message count as an exhausted pager. Anything else, including
-     *  undefined, means it was attempted. */
-    fetchOlder: () => Promise<boolean | void | any>;
-    /** The chat this fill was started for is gone (project switched, view
-     *  unmounted, gate token bumped). Checked between pages so a stale fill can
-     *  never keep paging another chat's history. */
-    isStale?: () => boolean;
-    maxPages?: number;
-};
-/**
- * Page older history until `isSatisfied`, until history runs out, or until the
- * pager stops advancing. Never throws: a failed page ends the fill, and the
- * user's own scrolling remains the fallback trigger.
- */
-declare function fillHistoryViewport(opts: FillHistoryViewportOptions): Promise<void>;
-/**
- * One fill loop per view, with predicates COMBINED rather than dropped.
- *
- * Fills come from several places at once — a first page finishing, a window
- * resize, a row being collapsed, and the user's own scroll to the top — and a
- * plain "one at a time, drop the rest" guard picks the wrong winner: a resize
- * fill (satisfied the moment the box can scroll at all) would swallow the user's
- * scroll-up (which needs content specifically ABOVE them), and the scroll-up
- * cannot be retried, because a reader parked at scrollTop 0 produces no further
- * scroll event. Dropping the guard entirely is no better: every frame of a
- * window drag would start its own 24-page loop.
- *
- * So a request that arrives mid-loop ANDs its predicate into the running one:
- * the loop then keeps paging until EVERY caller is satisfied. Predicates that
- * come true are dropped as it goes, so the cost stays flat.
- */
-declare function createHistoryFiller(base: Omit<FillHistoryViewportOptions, 'isSatisfied'> & {
-    /** Fired when the loop starts FETCHING and when it stops, and only on a real
-     *  change.
-     *
-     *  This — not the caller's own per-request `isLoading` — is what "older
-     *  history is still coming in" means to a view. A fill is many pages, and
-     *  `isLoading` drops to false between every one of them, so anything
-     *  rendered off it flickers once per page for the whole loop. A collapsed
-     *  indexing row whose run begins above the loaded window renders exactly
-     *  that ("still loading this run" vs a status it cannot know yet), which is
-     *  why the loop has to publish its own span.
-     *
-     *  Fetching, NOT requested. Most fills fetch nothing: they are fired on every
-     *  window resize, every row a user collapses, and every first-page load, and
-     *  the overwhelmingly common outcome is `isSatisfied` returning true on the
-     *  first look. Announcing at request time published a true/false pair for
-     *  each of those, and the widget's own satisfied-check spans two animation
-     *  frames — long enough for the browser to PAINT the intermediate state. Every
-     *  collapsed row strobed through "loading" on every resize tick. So the span
-     *  opens at the first actual page request, which is also the first moment the
-     *  claim is true. */
-    onRunningChange?: (running: boolean) => void;
-}): {
-    fill: (isSatisfied: () => boolean | Promise<boolean>) => Promise<void>;
-    isRunning: () => boolean;
-};
-
 declare const MCP_NAME = "BunnyQuery";
 declare const DEFAULT_CLAUDE_MODEL = "claude-sonnet-5";
 declare const DEFAULT_OPENAI_MODEL = "gpt-5.6-luna";
@@ -1160,6 +1210,61 @@ declare function extractOpenAIText(response: any): any;
 declare function listClaudeModels(service: string, owner: string): Promise<any>;
 declare function listOpenAIModels(service: string, owner: string): Promise<any>;
 declare const BG_INDEXING_QUEUE_SUFFIX = "-bg";
+/**
+ * unique_id of the durable "indexing finished" marker record for a stored file.
+ *
+ * Written by the BACKEND (the polling worker calls the MCP server's
+ * /internal/index-complete at the end of an auto_continue chain whose final
+ * window reported no more content) and, for completions a client knows
+ * deterministically (single-pass settle, client-chain completion token), by the
+ * consumer's mintIndexDoneMarker hook — never by the model.
+ * The marker record carries `reference: "src::<path>"`, so the reindex flow's
+ * delete of the src:: record cascades to it and a re-run starts unmarked.
+ *
+ * Existence semantics: present = the whole file was read to the end. Absent =
+ * unknown (still running, failed partway, indexed before this marker existed,
+ * or a single-pass run minted before the client hook existed) - callers must
+ * fall back to the live-queue probe (fetchLiveIndexingKeys) before reading
+ * absence as anything.
+ */
+declare function indexDoneUniqueId(storagePath: string): string;
+/**
+ * unique_id of the per-file indexing RUN record.
+ *
+ * One record per storage path, newest run wins (a reindex's delete-then-repost
+ * of src:: cascade-deletes the old record first, exactly like done::). Minted
+ * status='working' by the client the moment it enqueues a run's FIRST pass, and
+ * closed (done/error/cancelled) by whichever side observes the ending: the
+ * worker via the MCP internal routes for worker-driven chains, the client for
+ * deterministic settles, cancels, and dispatch failures. It exists so chat rows
+ * and files-page badges can answer "which runs exist and how did they end"
+ * from ONE records query instead of scanning bg history.
+ *
+ * A 'working' record is a claim, not proof: a chain that dies without reaching
+ * any error path leaves it dangling, so readers must treat a stale 'working'
+ * (old `started`, no live-queue confirmation) as unknown, never as live.
+ */
+declare function runIndexUniqueId(storagePath: string): string;
+type IndexRunStatus = 'working' | 'done' | 'error' | 'cancelled';
+type IndexRunPatch = {
+    status: IndexRunStatus;
+    filename?: string;
+    started?: number;
+    finished?: number;
+    error?: string;
+    queue?: string;
+    /** Chat that owns this run. A run:: record is keyed by storage path alone,
+     *  but a chat is per (project, platform) — without this the Claude chat's
+     *  runs surfaced as rows in the same project's ChatGPT chat, where their
+     *  passes can never load and the queue probe can never see them. */
+    platform?: 'claude' | 'openai';
+};
+/**
+ * Fire-and-forget wrapper over the consumer's upsertIndexRunRecord hook.
+ * Safe everywhere: missing hook, unconfigured engine, and consumer throws all
+ * reduce to a no-op — a run record must never be able to break the run itself.
+ */
+declare function upsertIndexRunRecordSafe(service: string, storagePath: string, patch: IndexRunPatch): void;
 /**
  * The one place the background-indexing queue name is spelled out. The backend
  * serialises requests sharing a queue name and runs different names in PARALLEL,
@@ -1217,7 +1322,234 @@ declare function getChatHistory(params: {
     platform: 'claude' | 'openai';
     queue?: string;
     status?: 'pending' | 'running' | 'resolved' | 'failed';
+    /** Exact-queue listing: without it the qid range is a PREFIX match, so
+     *  queue "u1" also returns "u1-bg" rows. Requires the updated polling
+     *  lambda; older backends ignore it (harmless, wider results). */
+    queue_exact?: boolean;
+    /** Label/marker STUBS instead of full bodies (see the polling lambda).
+     *  Older backends ignore it and return full items. */
+    compact?: boolean;
+    /** Drop one queue's rows from an id-prefix listing — how the surface
+     *  chat is fetched WITHOUT the bg-indexing queue while legacy items on
+     *  odd queue names survive. Older backends ignore it. */
+    queue_exclude?: string;
 }, fetchOptions: Record<string, any>): Promise<any>;
+/** Full server-side id of one history item, for a csr-poll POINT LOOKUP (the
+ *  single-item path returns the item WITH bodies — how an expanded row fetches
+ *  the passes a compact listing stubbed out). Mirrors the id the SDK builds:
+ *  `[METHOD]url#service:` + the item's own `stamp:entropy` id. */
+declare function buildHistoryItemFullId(platform: 'claude' | 'openai', service: string, itemId: string): string;
+
+/**
+ * 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. projectId is passed for link sanitization.
+ */
+
+declare function filterListByClearHorizon(list: any[], clearedAt: number): any[];
+declare function normalizeTextContent(content: any): string;
+declare function extractLastUserTextFromRequest(requestBody: any): string;
+/** 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. */
+declare function isIndexingRequestText(userText: any): boolean;
+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.
+ */
+declare function parseIndexingRequestText(userText: any): IndexingRequestRef | null;
+/**
+ * One bounded look at the background-indexing queue: which files still have a
+ * pass pending or running? This is the same negative signal ChatSession's
+ * display layer relies on - for a worker-driven (auto_continue) run, only the
+ * queue can say the run is over, because the worker enqueues continuation
+ * passes the client never dispatched.
+ *
+ * Returns every storage path AND file name found on live passes (both, because
+ * older prompts may lack the storage-path line), plus `checked`: false when a
+ * page came back full, in which case absence from `keys` proves nothing and
+ * the caller must keep whatever state it already had.
+ *
+ * SCOPE: the probed queue is "<userId>-bg" - THIS user's dispatches only. A
+ * chain launched by another collaborator or a widget end-user lives on their
+ * queue and is invisible here, so "idle" must never be read as "nobody is
+ * indexing this file", only as "this user's runs are over". The durable done::
+ * marker (indexDoneUniqueId) is the cross-user signal.
+ */
+declare function fetchLiveIndexingKeys(params: {
+    service: string;
+    owner: string;
+    platform: 'claude' | 'openai';
+    /** Same value the dispatch used - see bgIndexingQueueName. */
+    userId?: string;
+}): Promise<{
+    keys: Set<string>;
+    checked: boolean;
+    at: number;
+}>;
+/** Test hook: drop split-fetch state (all keys, or one). */
+declare function __resetSplitHistoryState(key?: string): void;
+type SplitHistoryResult = {
+    list: any[];
+    endOfList: boolean;
+    startKeyHistory: any[];
+    /** True when this chat had never been walked in this session — the first
+     *  paint. Consumers gate the "Loading indexing history" hint on it: a
+     *  mid-walk tab return restarts the walk for cursor safety but must stay
+     *  silent (flashing the hint on every return was the reported bug). */
+    firstLoad?: boolean;
+    /** Present only when `deferBg` was requested AND bg work remains: resolves
+     *  with the stub batch fetched in the background (the per-key lock is held
+     *  until it settles, so no other history call can interleave). The caller
+     *  merges the batch by timestamp — the same path older pages use. */
+    bgPending?: Promise<{
+        list: any[];
+        endOfList: boolean;
+    }>;
+};
+declare function getSplitChatHistory(params: {
+    service: string;
+    owner: string;
+    platform: 'claude' | 'openai';
+    userId?: string;
+}, fetchOptions: Record<string, any>, 
+/** Test seam: replaces getChatHistory. Not for production callers. */
+_fetchImpl?: typeof getChatHistory): Promise<SplitHistoryResult>;
+type MapHistoryOptions = {
+    clearedAt: number;
+    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;
+};
+declare function mapHistoryListToMessages(list: any[], platform: 'claude' | 'openai', opts: MapHistoryOptions): {
+    messages: any[];
+    runningItemIds: string[];
+};
+
+/**
+ * Keep older history REACHABLE by paging until the message box actually gains
+ * something to scroll to.
+ *
+ * Older history is paged in by one trigger only: the user scrolling to the top
+ * of the message box. That trigger has two ways to die, and collapsed indexing
+ * rows cause both:
+ *
+ *   1. The box never scrolls. A file's every indexing pass (the first plus every
+ *      CONTINUE pass, request AND response bubble each) folds into ONE row, so a
+ *      full history page — twenty-plus messages — can render as a single line.
+ *      Content shorter than the viewport fires no scroll event, so page 2 is
+ *      never requested and any conversation the user had before that upload is
+ *      permanently out of reach.
+ *   2. The fetched page adds no height. A page that is entirely the same file's
+ *      earlier passes joins the collapsed row already on screen and renders
+ *      nothing new. The user, sitting at scrollTop 0, scrolls up again — and
+ *      because the position never changed, no further scroll event fires.
+ *
+ * Both are the same shape: fetch, re-measure, and keep going until the user
+ * genuinely gained reachable content, history ran out, or the pager stopped
+ * advancing. `isSatisfied` is what differs between the two (can the box scroll
+ * at all / did it grow), so the loop below takes it as a predicate.
+ *
+ * DOM-free like the rest of the engine — the caller supplies the measurement and
+ * awaits its own render before measuring, so agent.vue and the widget run the
+ * identical loop over their own pagers.
+ */
+/** Overflow (px) that counts as "the user can scroll here". Comfortably more
+ *  than the 60px top threshold that triggers the next page, so a filled box has
+ *  real room to scroll rather than sitting one pixel from the trigger. */
+declare const HISTORY_FILL_SLACK_PX = 64;
+/** Pages one fill pass will request before giving up. Reached only by a chat
+ *  whose history really is dozens of pages of one file's indexing passes; the
+ *  cap exists so a pager that stops advancing can never spin forever. */
+declare const MAX_HISTORY_FILL_PAGES = 24;
+type FillHistoryViewportOptions = {
+    /** The user has reachable content and paging can stop. Called AFTER the
+     *  caller's own render has settled (nextTick / rAF), since only the caller
+     *  knows when its view has painted — hence the allowance for a promise. */
+    isSatisfied: () => boolean | Promise<boolean>;
+    /** All history is loaded — nothing left to page in. */
+    isEndOfList: () => boolean;
+    /** A history request is already in flight. Waited out, not treated as a stop
+     *  condition: a background first-page refresh (the queue-detect tick fires one
+     *  every couple of seconds while a file is indexing) would otherwise swallow
+     *  the user's scroll-up entirely, and scrolling up again from scrollTop 0
+     *  produces no second event to retry with. */
+    isLoading: () => boolean;
+    /** Messages currently loaded. Used to detect a page that added nothing, which
+     *  means the pager is not advancing and looping would never terminate. */
+    messageCount: () => number;
+    /** Fetch ONE older page (the caller's own fetchMore path, scroll-restore and
+     *  all). Return `false` when the request was NOT issued (the caller's own
+     *  single-flight guard swallowed it) so the loop retries instead of reading
+     *  the unchanged message count as an exhausted pager. Anything else, including
+     *  undefined, means it was attempted. */
+    fetchOlder: () => Promise<boolean | void | any>;
+    /** The chat this fill was started for is gone (project switched, view
+     *  unmounted, gate token bumped). Checked between pages so a stale fill can
+     *  never keep paging another chat's history. */
+    isStale?: () => boolean;
+    maxPages?: number;
+};
+/**
+ * Page older history until `isSatisfied`, until history runs out, or until the
+ * pager stops advancing. Never throws: a failed page ends the fill, and the
+ * user's own scrolling remains the fallback trigger.
+ */
+declare function fillHistoryViewport(opts: FillHistoryViewportOptions): Promise<void>;
+/**
+ * One fill loop per view, with predicates COMBINED rather than dropped.
+ *
+ * Fills come from several places at once — a first page finishing, a window
+ * resize, a row being collapsed, and the user's own scroll to the top — and a
+ * plain "one at a time, drop the rest" guard picks the wrong winner: a resize
+ * fill (satisfied the moment the box can scroll at all) would swallow the user's
+ * scroll-up (which needs content specifically ABOVE them), and the scroll-up
+ * cannot be retried, because a reader parked at scrollTop 0 produces no further
+ * scroll event. Dropping the guard entirely is no better: every frame of a
+ * window drag would start its own 24-page loop.
+ *
+ * So a request that arrives mid-loop ANDs its predicate into the running one:
+ * the loop then keeps paging until EVERY caller is satisfied. Predicates that
+ * come true are dropped as it goes, so the cost stays flat.
+ */
+declare function createHistoryFiller(base: Omit<FillHistoryViewportOptions, 'isSatisfied'> & {
+    /** Fired when the loop starts FETCHING and when it stops, and only on a real
+     *  change.
+     *
+     *  This — not the caller's own per-request `isLoading` — is what "older
+     *  history is still coming in" means to a view. A fill is many pages, and
+     *  `isLoading` drops to false between every one of them, so anything
+     *  rendered off it flickers once per page for the whole loop. A collapsed
+     *  indexing row whose run begins above the loaded window renders exactly
+     *  that ("still loading this run" vs a status it cannot know yet), which is
+     *  why the loop has to publish its own span.
+     *
+     *  Fetching, NOT requested. Most fills fetch nothing: they are fired on every
+     *  window resize, every row a user collapses, and every first-page load, and
+     *  the overwhelmingly common outcome is `isSatisfied` returning true on the
+     *  first look. Announcing at request time published a true/false pair for
+     *  each of those, and the widget's own satisfied-check spans two animation
+     *  frames — long enough for the browser to PAINT the intermediate state. Every
+     *  collapsed row strobed through "loading" on every resize tick. So the span
+     *  opens at the first actual page request, which is also the first moment the
+     *  claim is true. */
+    onRunningChange?: (running: boolean) => void;
+}): {
+    fill: (isSatisfied: () => boolean | Promise<boolean>) => Promise<void>;
+    isRunning: () => boolean;
+};
 
 /**
  * ChatSession host adapter + state types.
@@ -1314,6 +1646,10 @@ interface ChatMessage {
      *  which is how an 88-page file once "finished" at page 15. */
     _indexComplete?: boolean;
     _useBgQueue?: boolean;
+    /** Mapped from an item delivered by the bg chain of the split history fetch
+     *  (stubs or deferred chats). Surface-frontier logic (retention boundary,
+     *  clear-horizon) skips these — their ids reach arbitrarily deep. */
+    _fromBgChain?: 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 —
@@ -1353,6 +1689,9 @@ interface ChatState {
     typingAbort: boolean;
     loadingHistory: boolean;
     loadingOlderHistory: boolean;
+    /** A deferred bg stub batch (first-paint split fetch) is still in flight;
+     *  views show a small 'loading indexing history' hint while true. */
+    bgHistoryLoading: boolean;
     historyEndOfList: boolean;
     historyStartKeyHistory: string[];
     historyRequestToken: number;
@@ -1656,6 +1995,15 @@ type IndexingGroup = {
      *  loaded ones. 'status': the queue has not yet said whether this file is still
      *  being worked on, which is the only thing that can end a worker-driven run. */
     resolvingReason?: 'history' | 'status';
+    /** Synthesized from a durable run:: record: none of the run's passes are
+     *  among the loaded messages (bg history still deferred, or the run is older
+     *  than the paging cap). Header-and-status only — members/visibleMembers are
+     *  empty and there is nothing to cancel; the row is replaced by the real
+     *  group the moment actual passes load (same `key`, so expansion state
+     *  carries over). */
+    stub?: boolean;
+    /** The run:: record's stored error text, for a stub row's meta line. */
+    stubError?: string;
 };
 type DisplayEntry = {
     kind: 'message';
@@ -1686,6 +2034,16 @@ type BuildDisplayListOptions = {
     /** Whether `liveIndexKeys` has been answered at least once for this chat. False
      *  is "we do not know", and a worker-driven run stays unfinished on it. */
     liveIndexChecked?: boolean;
+    /** Files carrying the durable done:: completion marker (one prefix sweep),
+     *  keyed like IndexingGroup.key (storage path; the bare-name fallback keys
+     *  of very old prompts simply never match — they keep the queue inference).
+     *  A marker is PROOF the file was read to the end: it settles a worker-run
+     *  green without waiting for the queue answer, and it is never withheld by
+     *  the resolving logic. A live queue hit still outranks it (a re-index in
+     *  flight whose marker-cascade delete lagged). */
+    doneKeys?: {
+        [fileKey: string]: boolean;
+    };
     /** Server item ids of passes that were on a row when the user STOPPED it
      *  (ChatSession.state.stoppedIndexIds). A run holding any of them is a run the
      *  user stopped — see the status derivation for why a stop usually leaves no
@@ -1698,7 +2056,51 @@ type BuildDisplayListOptions = {
      *  windowedIndexing). Passed in rather than read from config so this stays a
      *  pure function of its inputs and can be exercised for both settings. */
     windowedIndexing?: boolean;
+    /** Durable run:: records, keyed by STORAGE PATH (the consumer's marker
+     *  sweep). Each key with no real group in the loaded messages gets a
+     *  synthesized header-only row (see IndexingGroup.stub), placed by its
+     *  `started` timestamp. A real group for the same file — matched by key,
+     *  path, or name — always suppresses the stub: loaded passes are evidence,
+     *  the record is only a summary. */
+    runStubs?: {
+        [storagePath: string]: RunStubInfo;
+    };
+    /** The platform whose chat this list is for. run:: records are per-FILE,
+     *  but a chat is per (project, platform): a run started under Claude has
+     *  its passes in the Claude conversation and is invisible to the
+     *  OpenAI-scoped queue probe, so its stub could never be covered and never
+     *  be confirmed — it just sat there, in a chat it did not belong to.
+     *  Records minted before this was stamped carry no platform and are shown
+     *  in both, which keeps the leak to the historical set. */
+    stubPlatform?: 'claude' | 'openai';
+    /** The chat's clear-history horizon (ms epoch). Run records are service-
+     *  wide and know nothing about a cleared chat, so without this every
+     *  "Clear chat history" resurrects one row per indexed file. A stub whose
+     *  run ended (or, unfinished, began) at or before this moment is dropped —
+     *  unless the queue says the file is live RIGHT NOW, which no horizon can
+     *  make untrue. */
+    stubClearedAt?: number;
+    /** Clock injection for tests; defaults to Date.now(). Only run-stub
+     *  staleness reads it. */
+    now?: number;
+};
+/** The display-relevant fields of a run:: record (see requests.ts
+ *  runIndexUniqueId for the record's contract). */
+type RunStubInfo = {
+    status: 'working' | 'done' | 'error' | 'cancelled';
+    filename?: string;
+    started?: number;
+    finished?: number;
+    error?: string;
+    /** Chat that owns this run. Absent on records minted before it was
+     *  stamped; see BuildDisplayListOptions.stubPlatform. */
+    platform?: 'claude' | 'openai';
 };
+/** A 'working' run record older than this with no live-queue confirmation is
+ *  treated as unknown rather than live: a chain that died without reaching any
+ *  error path leaves 'working' dangling, and a row must not spin forever on a
+ *  claim nothing can end. */
+declare const RUN_RECORD_WORKING_STALE_MS: number;
 declare function parseIndexingLabel(content: string): {
     name: string;
     path?: string;
@@ -2004,6 +2406,17 @@ declare class ChatSession {
     resumePolling(reason: string): Promise<void>;
     private _newLocalId;
     getHistoryCacheKey(): string;
+    private _hydratedBodies;
+    private _hydratingItems;
+    /** Re-apply memoized hydrated texts onto freshly-mapped messages. Both
+     *  clients call this right after their mapper runs (loadHistory does it
+     *  internally); it mutates the given array's items in place. */
+    applyHydratedBodies(messages: ChatMessage[]): void;
+    /** Fetch the real response bodies for compact history stubs (one csr-poll
+     *  point lookup per item id), memoize, and swap them into the live list.
+     *  Best-effort: a failed lookup leaves the stub (its head + fallback line
+     *  still render) and a later expand retries. */
+    hydrateCompactItems(itemIds: string[]): Promise<void>;
     updateHistoryCache(): void;
     /**
      * Land a resolved reply in the history cache of a chat that is NOT currently
@@ -2274,6 +2687,10 @@ declare class ChatSession {
      */
     private _adoptingWorkerPasses;
     private _adoptWorkerIndexingPasses;
+    /** Anything at all suggesting THIS project's indexing may be live: a queued
+     *  local entry, a recorded live key (the adopt look just wrote them), or an
+     *  attached poll. Gates the passive adopt ladder's climb. */
+    private _hasLiveIndexEvidence;
     /** Any of these ids still queued or still polled, i.e. surviving work. */
     private _isTrackingAny;
     /** One live bg-queue item -> a BgTaskEntry, if it is an indexing pass this
@@ -2285,6 +2702,28 @@ declare class ChatSession {
      *  cancelQueuedMessage, which drives one, has nothing to act on). */
     private _cancelServerItem;
     drainBgTaskQueue(): void;
+    /** Fire the consumer's done::-marker hook for a run whose completion this
+     *  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: BgTaskEntry): void;
+    /** Short, storable form of an error body for the run:: record. */
+    _runErrorText(response: any): string;
+    /** Close the records of a run whose pass settled OFF-POLL — the answer came
+     *  back as history (hidden tab, dead poll, resume refetch), so none of the
+     *  poll-side settle handlers ran. Only for SINGLE-PASS files, where one
+     *  settled pass is deterministically the whole run (the same contract as
+     *  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: BgTaskEntry): void;
+    /** Close the durable run:: record for an ending THIS client observed.
+     *  service comes from the ENTRY, not the current identity: unlike the done::
+     *  mint above, a status flip must land even if the user switched projects
+     *  mid-settle — otherwise the record lies 'working' forever. Best-effort
+     *  through upsertIndexRunRecordSafe; the consumer's precedence guard keeps
+     *  repeats and races harmless. */
+    _flipRunRecord(entry: BgTaskEntry, status: IndexRunStatus, error?: string): void;
     maybeResumeIndexing(entry: BgTaskEntry, response: any, platform: string): void;
     loadHistory(fetchMore?: boolean, token?: number): Promise<void>;
     uploadSingleAttachment(att: any, stageId?: string): Promise<Array<{
@@ -2301,4 +2740,4 @@ declare class ChatSession {
     bumpGate(): void;
 }
 
-export { type AiAgentPlatform, type AttachmentFailureGroup, type AttachmentParser, type AttachmentSaveInfo, BG_INDEXING_QUEUE_SUFFIX, BOM, BOM_EXTS, type BgTaskEntry, type BoundedChatOptions, type BuildDisplayListOptions, type BuildIndexingUserMessageOptions, CLAUDE_INPUT_CAP_RATIO, CLAUDE_PER_REQUEST_INPUT_CAP, CONTEXT_WINDOW_BY_MODEL, CONTEXT_WINDOW_DEFAULT, type CallClaudeWithMcpParams, type ChatEngineConfig, type ChatHost, type ChatIdentity, type ChatMessage, ChatSession, type ChatState, type ChatSystemPromptParams, type ClaudeMcpServerRequest, type ClaudeMcpToolConfig, type ClaudeMessage, type ClaudeRole, type ComposedUserMessage, DEFAULT_CLAUDE_MODEL, DEFAULT_OPENAI_MODEL, type DisplayEntry, EMPTY_INDEXING_REPLY, EXPIRED_ATTACHMENT_URL_HOST, EXPIRED_ATTACHMENT_URL_ORIGIN, EXPIRED_LINK_REFRESH_EXPIRES_SECONDS, EXT_CONTENT_TYPES, type EncodingClass, type ExtractDirective, type FillHistoryViewportOptions, HISTORY_BUDGET_RATIO, HISTORY_FILL_SLACK_PX, HISTORY_TOKEN_BUDGET, HTML_EXTS, HTML_HEAD_WINDOW, IMAGE_PREVIEWS_PER_MESSAGE, INDEXING_COMPLETE_MARKER, INLINE_LINK_GLYPH, INLINE_LINK_UNAVAILABLE_GLYPH, INLINE_LINK_UNAVAILABLE_SUFFIX, type ImagePreviewContext, type IndexingAttachmentInfo, type IndexingFileRef, type IndexingGroup, type IndexingGroupStatus, type IndexingRequestRef, type IndexingSystemPromptParams, type InlineLinkContext, type InlineLinkMarkupOptions, type InlineLinkPart, LINK_LABEL_MAX_DISPLAY_CHARS, LINK_REFRESH_WINDOW_MS, MAX_CONCURRENT_BG_POLLS, MAX_HISTORY_FILL_PAGES, MAX_HISTORY_MESSAGES, MAX_PARSED_CONTENT_CHARS, MCP_NAME, MIN_INPUT_TOKEN_BUDGET, type MapHistoryOptions, OUTPUT_TOKEN_RESERVE, type OpenAIMessage, POLL_INTERVAL, PREVIEWABLE_IMAGE_CONTENT_TYPES, PREVIEW_BROWSER_CACHE_SECONDS, type ParsedAiAgent, type PinnedDispatchContext, type PreviewImageEl, RENDER_FROM_TOKEN, RTF_EXTS, type RenderableInlineLink, TOOL_AND_RESPONSE_BUFFER, type VisionProfile, XML_EXTS, applyEncodingDeclaration, bgIndexingQueueName, buildAiAgentValue, buildBoundedChatMessages, buildChatDisplayList, buildChatSystemPrompt, buildDisplayExpiredAttachmentHref, buildIndexingContinueMessage, buildIndexingRenderContinueTemplate, buildIndexingRenderMessage, buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingWindowMessage, callClaudeWithMcp, callClaudeWithPublicMcp, callOpenAIWithPublicMcp, chatEngineConfig, classifyInlineLink, clearAttachmentParsers, clearImagePreviewCache, composeUserMessage, configureChatEngine, contentTypeForExt, createHistoryFiller, createInlineLinkRegex, encodePathSegments, encodingClassForExt, ensureHtmlCharset, ensureXmlEncoding, escapeInlineHtml, escapeRtfNonAscii, estimateMessageTokens, estimateTextTokens, extOf, extractClaudeText, extractLastUserTextFromRequest, extractOpenAIText, extractRemotePathFromAttachmentHref, fillHistoryViewport, filterListByClearHorizon, findAttachmentParser, formatChatTimestamp, getAttachmentParsers, getChatHistory, getContextWindow, getErrorMessage, getExpiredAttachmentVisiblePath, getProjectContextWindow, getVisionProfile, groupAttachmentFailures, hasBom, hydrateImagePreviews, isAuthExpiredError, isBgIndexingQueue, isErrorResponseBody, isHttpUrlLike, isIndexingRequestText, isLinkUnavailable, isNonRetryableRequestError, isOfficeFile, isPreviewableImagePath, isServerExtractable, isServiceDbAttachmentHref, linkUnavailableKeyForHref, linkUnavailableKeyForPath, listClaudeModels, listOpenAIModels, looksLikeRtf, makeExtractPlaceholder, mapHistoryListToMessages, markImagePreviewStale, needsBomForExt, normalizeAttachmentPathCandidate, normalizeExt, normalizeTextContent, normalizeTrailingInlineToken, notifyAgentSaveAttachment, parseAiAgentValue, parseAttachmentContent, parseIndexingLabel, parseIndexingRequestText, peekImagePreviewUrl, prepareDownloadText, previewImageContentType, previewableExtOf, readExpiredAttachmentHref, registerAttachmentParser, registerModelContextWindows, renderInlineLinkHtml, repairUrlEntities, repairUrlWhitespace, resolveImagePreviewUrl, safeDecodeURIComponent, sanitizeAttachmentLinksForHistory, setProjectContextWindow, stripFileBlocksFromHistory, transformContentWithImages, transformContentWithOpenAIImages, truncateLabelForDisplay, wallClockNow };
+export { type AiAgentPlatform, type AttachmentFailureGroup, type AttachmentParser, type AttachmentSaveInfo, BG_INDEXING_QUEUE_SUFFIX, BOM, BOM_EXTS, type BgTaskEntry, type BoundedChatOptions, type BuildDisplayListOptions, type BuildIndexingUserMessageOptions, CLAUDE_INPUT_CAP_RATIO, CLAUDE_PER_REQUEST_INPUT_CAP, CONTEXT_WINDOW_BY_MODEL, CONTEXT_WINDOW_DEFAULT, type CallClaudeWithMcpParams, type ChatEngineConfig, type ChatHost, type ChatIdentity, type ChatMessage, ChatSession, type ChatState, type ChatSystemPromptParams, type ClaudeMcpServerRequest, type ClaudeMcpToolConfig, type ClaudeMessage, type ClaudeRole, type ComposedUserMessage, DEFAULT_CLAUDE_MODEL, DEFAULT_CONTEXT_WINDOW, DEFAULT_OPENAI_MODEL, type DisplayEntry, EMPTY_INDEXING_REPLY, EXPIRED_ATTACHMENT_URL_HOST, EXPIRED_ATTACHMENT_URL_ORIGIN, EXPIRED_LINK_REFRESH_EXPIRES_SECONDS, EXT_CONTENT_TYPES, type EncodingClass, type ExtractDirective, type FillHistoryViewportOptions, HISTORY_BUDGET_RATIO, HISTORY_FILL_SLACK_PX, HISTORY_TOKEN_BUDGET, HTML_EXTS, HTML_HEAD_WINDOW, IMAGE_PREVIEWS_PER_MESSAGE, INDEXING_COMPLETE_MARKER, INLINE_LINK_GLYPH, INLINE_LINK_UNAVAILABLE_GLYPH, INLINE_LINK_UNAVAILABLE_SUFFIX, INPUT_CAP_RATIO, type ImagePreviewContext, type IndexRunPatch, type IndexRunStatus, type IndexingAttachmentInfo, type IndexingFileRef, type IndexingGroup, type IndexingGroupStatus, type IndexingRequestRef, type IndexingSystemPromptParams, type InlineLinkContext, type InlineLinkMarkupOptions, type InlineLinkPart, LINK_LABEL_MAX_DISPLAY_CHARS, LINK_REFRESH_WINDOW_MS, MAX_CONCURRENT_BG_POLLS, MAX_HISTORY_FILL_PAGES, MAX_HISTORY_MESSAGES, MAX_OUTPUT_BY_MODEL, MAX_OUTPUT_TOKENS, MAX_PARSED_CONTENT_CHARS, MCP_NAME, MINT_CACHE_GENERATION, MIN_INPUT_TOKEN_BUDGET, MIN_PER_REQUEST_INPUT_CAP, type MapHistoryOptions, OUTPUT_TOKEN_RESERVE, type OpenAIMessage, POLL_INTERVAL, PRESIGN_SAFETY_MARGIN_MS, PREVIEWABLE_IMAGE_CONTENT_TYPES, PREVIEW_BROWSER_CACHE_SECONDS, PREVIEW_URL_EXPIRES_SECONDS, type ParsedAiAgent, type PinnedDispatchContext, type PreviewImageEl, RENDER_FROM_TOKEN, RTF_EXTS, RUN_RECORD_WORKING_STALE_MS, type RenderableInlineLink, type RunStubInfo, TOOL_AND_RESPONSE_BUFFER, type VisionProfile, XML_EXTS, __resetSplitHistoryState, applyEncodingDeclaration, bgIndexingQueueName, buildAiAgentValue, buildBoundedChatMessages, buildChatDisplayList, buildChatSystemPrompt, buildDisplayExpiredAttachmentHref, buildHistoryItemFullId, buildIndexingContinueMessage, buildIndexingRenderContinueTemplate, buildIndexingRenderMessage, buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingWindowMessage, callClaudeWithMcp, callClaudeWithPublicMcp, callOpenAIWithPublicMcp, chatEngineConfig, classifyInlineLink, clearAttachmentParsers, clearImagePreviewCache, composeUserMessage, configureChatEngine, contentTypeForExt, createHistoryFiller, createInlineLinkRegex, encodePathSegments, encodingClassForExt, ensureHtmlCharset, ensureXmlEncoding, escapeInlineHtml, escapeRtfNonAscii, estimateMessageTokens, estimateTextTokens, extOf, extractClaudeText, extractLastUserTextFromRequest, extractOpenAIText, extractRemotePathFromAttachmentHref, fetchLiveIndexingKeys, fillHistoryViewport, filterListByClearHorizon, findAttachmentParser, formatChatTimestamp, getAttachmentParsers, getChatHistory, getContextWindow, getErrorMessage, getExpiredAttachmentVisiblePath, getInputTokenBudget, getMaxOutputTokens, getModelContextWindow, getProjectContextWindow, getSplitChatHistory, getVisionProfile, groupAttachmentFailures, hasBom, hydrateImagePreviews, indexDoneUniqueId, isAuthExpiredError, isBgIndexingQueue, isErrorResponseBody, isHttpUrlLike, isIndexingRequestText, isLinkUnavailable, isNonRetryableRequestError, isOfficeFile, isPreviewableImagePath, isProviderApiKeyError, isServerExtractable, isServiceDbAttachmentHref, linkUnavailableKeyForHref, linkUnavailableKeyForPath, linkUnavailableKeysForPath, listClaudeModels, listOpenAIModels, looksLikeRtf, makeExtractPlaceholder, mapHistoryListToMessages, markImagePreviewStale, mintCacheBustStamp, needsBomForExt, normalizeAttachmentPathCandidate, normalizeExt, normalizeTextContent, normalizeTrailingInlineToken, notifyAgentSaveAttachment, parseAiAgentValue, parseAttachmentContent, parseIndexingLabel, parseIndexingRequestText, peekImagePreviewUrl, prepareDownloadText, presignExpiryEpochMs, previewImageContentType, previewMintCacheToken, previewableExtOf, readExpiredAttachmentHref, registerAttachmentParser, registerModelContextWindows, renderInlineLinkHtml, repairUrlEntities, repairUrlWhitespace, resolveImagePreviewUrl, runIndexUniqueId, safeDecodeURIComponent, sanitizeAttachmentLinksForHistory, setProjectContextWindow, stripFileBlocksFromHistory, transformContentWithImages, transformContentWithOpenAIImages, truncateLabelForDisplay, upsertIndexRunRecordSafe, wallClockNow };