@mikedown/core 0.2.0 → 0.3.0

package/dist/ai/index.d.ts

@@ -0,0 +1,1531 @@
+import { b as AiModelCapabilities, c as AiCapabilityFlag, d as AiSendsScope, e as AiFeatureSettings, f as AiLocality, g as AiEngineConfig, h as AiEngineKind, i as AiModelConfig, j as AiDiscoveredModel, k as AiApiKeyFile, A as AiSettings, a as AiEngineStatus, l as AiFinishReason, m as AiUsage, n as AiErrorCode, o as AiCompletionResult, p as AiCompletionRequest, q as AiMessage, r as AiError, s as AiConsentRecord, t as AiLocalServerProbe, u as AiHardwareInfo, v as AiHostEngineProbe } from '../types-CgEeIUhi.js';
+export { w as AI_CAPABILITY_FLAGS, x as AI_ENGINE_KINDS, y as AI_ERROR_CODES, z as AI_FALLBACK_MODES, B as AI_HOST_ENGINE_KINDS, C as AiCapabilitiesSource, D as AiConsentAbout, E as AiConsentReply, F as AiEngineStatusModel, G as AiFallbackMode, H as AiFeatureSetting, I as AiKeySource, J as AiLocalitySetting, K as AiMessagePart, L as AiRoute, N as AiRouting, O as AiServedBy, P as AiTiming, Q as DEFAULT_CONTEXT_TOKENS, M as MikeDownAiHost, R as ProviderAdapter } from '../types-CgEeIUhi.js';
+export { a as AI_SETTINGS_KEYS, A as AiSettingsPatch, P as ParseAiSettingsOptions, g as generateAiId, i as isHostEngineKind, b as isKnownEngineKind, p as parseAiSettings, s as serializeAiSettings } from '../schema-DYzxkuSb.js';
+
+/**
+ * Task taxonomy. A feature names a task; the router picks the engine and
+ * model routed to that task and checks the model has what the task needs.
+ * Task ids are the keys of `routing.tasks`; unknown ids saved by a newer
+ * version are kept and route like any other (with no requirements).
+ */
+
+/** A task's needs. Booleans must be true on the model; `contextTokens` is a minimum. */
+type AiCapabilityRequirements = Partial<AiModelCapabilities>;
+interface AiTaskDefinition {
+    id: string;
+    label: string;
+    description: string;
+    requires: AiCapabilityRequirements;
+    /**
+     * Nice to have, never a gate: the router tries candidates that meet these
+     * first and still uses one that does not (a model without JSON mode, a
+     * small context window).
+     */
+    prefers?: AiCapabilityRequirements;
+    /** At least one of these flags must be true (ghost text: a FIM model, or a chat model with a continue prompt). */
+    requiresAny?: AiCapabilityFlag[];
+    /** Served by a host method rather than a model completion. */
+    hostMethod?: 'embed' | 'transcribe';
+}
+/** The "comfortable" context for `summarize`: preferred by the router, and the point below which the UI may warn. Not a gate. */
+declare const SUMMARIZE_MIN_CONTEXT_TOKENS = 32768;
+declare const AI_TASKS: readonly AiTaskDefinition[];
+declare function getAiTask(id: string): AiTaskDefinition | undefined;
+/** Merge two requirement sets: flags OR together, `contextTokens` takes the larger minimum. */
+declare function combineRequirements(a: AiCapabilityRequirements, b: AiCapabilityRequirements): AiCapabilityRequirements;
+/**
+ * The capabilities a model lacks for these requirements, as flag names (and
+ * `contextTokens` when the window is too small). Empty means it qualifies.
+ * An unknown context window counts as `DEFAULT_CONTEXT_TOKENS`.
+ */
+declare function missingCapabilities(caps: AiModelCapabilities, requires: AiCapabilityRequirements, requiresAny?: readonly AiCapabilityFlag[], defaultContextTokens?: number): Array<keyof AiModelCapabilities>;
+
+/**
+ * Feature registry. A feature's defaults (on or off, which task it uses,
+ * what else it needs from a model) live here, so adding a feature is one
+ * entry plus its UI and never a settings migration. `features.<id>` in
+ * settings overrides `enabled` and `task`.
+ */
+
+interface AiFeatureDefinition {
+    id: string;
+    label: string;
+    description: string;
+    defaultEnabled: boolean;
+    defaultTask: string;
+    /** Needs on top of the task's own. */
+    requires: AiCapabilityRequirements;
+    /** `planned` features are listed greyed ("coming later") and never surface. */
+    status: 'available' | 'planned';
+    /** What a request sends, for the consent dialogs and tooltips (`whatIsSent`). Absent: a generic sentence. */
+    sends?: AiSendsScope;
+}
+declare const AI_FEATURES: readonly AiFeatureDefinition[];
+declare function getAiFeature(id: string): AiFeatureDefinition | undefined;
+interface ResolvedAiFeature {
+    id: string;
+    /** Saved value, else the registry default. Unknown features default to off. */
+    enabled: boolean;
+    /** Saved override, else the registry default task, else the feature id. */
+    task: string;
+    requires: AiCapabilityRequirements;
+    definition?: AiFeatureDefinition;
+}
+/** A feature's effective state from saved settings plus the registry. Ignores the master switch. */
+declare function resolveAiFeature(features: AiFeatureSettings, id: string): ResolvedAiFeature;
+
+/**
+ * Local or cloud, from an engine's base URL. Loopback, link-local, IPv6
+ * unique-local, `localhost`, `.local`, `.lan`, `.home.arpa` and `.internal`
+ * are always local; `localNetworks` adds CIDR ranges (RFC 1918 by default, a
+ * WireGuard range such as `10.0.98.0/24`) and `.suffix` host names. Anything
+ * else, including a URL that does not parse, is cloud.
+ */
+
+/** Default `mikedown.ai.localNetworks`: RFC 1918. */
+declare const DEFAULT_LOCAL_NETWORKS: readonly string[];
+/** Lower-cased host of a URL (no port, no brackets), or null. Accepts a bare `host:port`. */
+declare function hostOfUrl(url: string): string | null;
+/**
+ * `local` or `cloud` for a base URL. `localNetworks` entries are IPv4 CIDR
+ * ranges (`10.0.98.0/24`, a bare address counts as /32) or host-name
+ * suffixes (`.ts.net`, `studio.example.com`).
+ */
+declare function detectLocality(baseUrl: string, localNetworks?: readonly string[]): AiLocality;
+/**
+ * The engine's effective locality: its pin, or `detectLocality` for `auto`.
+ * A `vscode-lm` engine is always cloud, whatever its pin: it has no address,
+ * and the text goes to GitHub's Copilot service.
+ */
+declare function engineLocality(engine: Pick<AiEngineConfig, 'baseUrl' | 'locality'> & {
+    kind?: string;
+}, localNetworks?: readonly string[]): AiLocality;
+/**
+ * True when a pinned locality disagrees with the URL (cloud pinned on a
+ * private address, or local pinned on a public one). The indicator shows a
+ * warning glyph for it.
+ */
+declare function localityMismatch(engine: Pick<AiEngineConfig, 'baseUrl' | 'locality'> & {
+    kind?: string;
+}, localNetworks?: readonly string[]): boolean;
+
+/**
+ * Capability detection for models the endpoint does not describe (oMLX and
+ * most OpenAI-compatible servers list bare ids). Order of trust: endpoint
+ * metadata, then these heuristics, then user edits, which always win and
+ * survive re-discovery (`capabilitiesSource: 'user'`).
+ *
+ * Local models: an ordered regex table of families; every matching rule
+ * applies in order, so later, more specific rules override earlier ones.
+ * Cloud models (Anthropic, OpenAI): static tables matched by the longest id
+ * prefix, so a new model in a known line inherits its line's values.
+ */
+
+type CloudTable = Array<{
+    prefix: string;
+    caps: Partial<AiModelCapabilities>;
+}>;
+/** Anthropic models, matched by the longest prefix. Unknown `claude-*` ids get the generic row. */
+declare const ANTHROPIC_MODEL_TABLE: CloudTable;
+/** OpenAI models, matched by the longest prefix. */
+declare const OPENAI_MODEL_TABLE: CloudTable;
+/**
+ * OpenAI's reasoning models, which take only the default sampling: Chat
+ * Completions rejects a `temperature` or `top_p` other than 1 for them. The
+ * native `openai` kind matches on the id; any other kind only on an
+ * `openai/` id (OpenRouter), so a local model that happens to be called
+ * `o3-something` keeps its sampling. `-chat-latest` snapshots match too:
+ * the default sampling costs nothing there.
+ */
+declare function isOpenAiReasoningModel(modelId: string, kind?: AiEngineKind): boolean;
+/**
+ * The `reasoning_effort` that means "Off" for an OpenAI reasoning model, or
+ * null when `modelId` is not one (the caller leaves the request alone). The
+ * Thinking dial stores Off as `none`, which only some families accept:
+ *
+ * - `gpt-5.1` onwards in the 5.x line (5.5 included): `none`.
+ * - `gpt-5`, `gpt-5-mini`, `gpt-5-nano`: `minimal`.
+ * - everything else (o-series, `gpt-6`+, codex and pro variants, ids not
+ *   documented yet): `low`, the one value every reasoning family accepts.
+ *   Newer models reject `none` (and some `minimal`), so unknown means `low`.
+ */
+declare function openAiOffReasoningEffort(modelId: string, kind?: AiEngineKind): 'none' | 'minimal' | 'low' | null;
+interface DetectedCapabilities {
+    capabilities: AiModelCapabilities;
+    /** The family rule or table prefix that matched last, or null for the generic default. */
+    family: string | null;
+}
+/**
+ * Capabilities guessed from a model id. A `vscode-lm` model is a plain chat
+ * model (the endpoint gives its context window). Anthropic and OpenAI engines use
+ * their static tables; any engine whose id (after a `vendor/` prefix, as on
+ * OpenRouter) starts with `claude-` or a known OpenAI line does too. An id
+ * nothing matches is a plain chat model with `DEFAULT_CONTEXT_TOKENS`.
+ */
+declare function detectCapabilities(modelId: string, kind?: AiEngineKind): DetectedCapabilities;
+/** Endpoint values over heuristics: fields the endpoint left out (or null) come from the id. */
+declare function completeCapabilities(partial: Partial<AiModelCapabilities>, modelId: string, kind?: AiEngineKind): AiModelCapabilities;
+/**
+ * Merge one discovery into an engine's saved models, by id:
+ *
+ * - listed and saved: `endpoint`/`heuristic` rows get the fresh values, `user`
+ *   rows keep theirs; `enabled`, `label` and `requestOverrides` are kept, and
+ *   `missing` is cleared;
+ * - saved but not listed: marked `missing: true` (greyed, not deleted), except
+ *   manual entries, which are left alone;
+ * - listed but new: appended in discovery order, enabled unless
+ *   `opts.addEnabled` is false. Cloud engines pass false (OPEN-12): a
+ *   300-model list must not flood the routing pickers, so the user picks.
+ */
+declare function mergeDiscoveredModels(existing: readonly AiModelConfig[], discovered: readonly AiDiscoveredModel[], kind?: AiEngineKind, opts?: {
+    addEnabled?: boolean;
+}): AiModelConfig[];
+
+/**
+ * "Add engine" presets. A preset only fills the new engine's name, kind, base
+ * URL, key variable and key file; everything else is the user's. Presets also
+ * drive the Express engine form: which family a card sits in, the caption
+ * under it, where to get a key, and which fetched models count as Popular.
+ *
+ * No model ids here: they go stale, and the endpoint is the source of truth.
+ * Popular rules are patterns matched against whatever the endpoint lists.
+ */
+
+/**
+ * Where a preset runs: your own server, a cloud API you paste a key for, or
+ * a model API built into the host (`host`: VS Code's GitHub Copilot models,
+ * no address and no key; shown only where the host reports it).
+ */
+type AiPresetFamily = 'local' | 'cloud' | 'host';
+/**
+ * One Popular slot: the newest fetched id that matches `match` (and not
+ * `exclude`). An id `prefer` matches (an alias such as `-latest`) wins;
+ * otherwise "newest" compares the version numbers in the id, then a date
+ * stamp.
+ */
+interface AiPopularRule {
+    /** Short family name, for the picker's tooltip ("Sonnet"). */
+    label: string;
+    match: RegExp;
+    exclude?: RegExp;
+    prefer?: RegExp;
+}
+interface AiEnginePreset {
+    id: string;
+    name: string;
+    kind: AiEngineKind;
+    baseUrl: string;
+    apiKeyEnv?: string;
+    apiKeyFile?: AiApiKeyFile;
+    /** Whether the endpoint expects a key at all (LM Studio accepts any). */
+    needsKey: boolean;
+    family: AiPresetFamily;
+    /** The quick-start card's one-line caption. */
+    caption: string;
+    /** Under the API key field: where to get one, or whether one is needed. A link to `keyUrl` when it has one. */
+    keyHint: string;
+    /** Cloud presets: the provider's page that creates API keys, opened through the host's `openLink`. */
+    keyUrl?: string;
+    /** Cloud presets: the Popular group, in order. The first rule that matches is the auto-picked default. */
+    popular?: readonly AiPopularRule[];
+    /**
+     * Local presets: the path (from the server root, without `/v1`) that local
+     * server detection GETs when it is not `{baseUrl}/models`. The native lists
+     * answer without a key.
+     */
+    detectPath?: string;
+    /** Cloud and host presets: the provider's own page on how API data is used (see `privacy.ts`). */
+    policy?: AiProviderPolicy;
+    /**
+     * Cloud presets: the provider's official API pricing page, linked as
+     * "Pricing" beside the key link. Only the link: prices change, so no
+     * figure is stated in code. URLs checked 2026-10-29.
+     */
+    pricingUrl?: string;
+    /**
+     * Local presets: the official download or install page, for a server that
+     * is not running yet ("Install", then Look again). URLs checked 2026-10-29.
+     */
+    installUrl?: string;
+}
+/**
+ * A provider's official privacy or API data-use page. Only the link: what a
+ * provider does with the text is set by its terms, which change, so no claim
+ * about training or retention is made in code. URLs checked 2026-10-29.
+ */
+interface AiProviderPolicy {
+    /** Link text ("Anthropic privacy and data use"). */
+    label: string;
+    url: string;
+    /** One extra neutral sentence, for a provider that passes requests on (OpenRouter). */
+    note?: string;
+}
+interface AiPresetFamilyInfo {
+    family: AiPresetFamily;
+    /** Group heading over the quick-start cards. */
+    label: string;
+    /** The "two ways to connect" line for this family. */
+    explainer: string;
+}
+/**
+ * The two quick-start groups, in display order, with the "two ways to
+ * connect" copy. The `host` family is not in this list: it shows only on a
+ * host whose `detectHostEngines` reports a model (`AI_HOST_PRESET_FAMILY`).
+ */
+declare const AI_PRESET_FAMILIES: readonly AiPresetFamilyInfo[];
+/** The `host` group (VS Code's built-in models), for the hosts that report one through `detectHostEngines`. */
+declare const AI_HOST_PRESET_FAMILY: AiPresetFamilyInfo;
+declare const AI_ENGINE_PRESETS: readonly AiEnginePreset[];
+/**
+ * The preset a saved engine most likely came from (engines do not store
+ * one): same kind and address, then the same key variable as a tiebreak
+ * (oMLX and vLLM share port 8000); else, for a cloud address, the preset on
+ * the same host; else the one preset of a dedicated kind. Undefined when
+ * nothing fits (a hand-made OpenAI-compatible engine).
+ */
+declare function presetForEngine(engine: {
+    kind: string;
+    baseUrl: string;
+    apiKeyEnv?: string;
+}, presets?: readonly AiEnginePreset[]): AiEnginePreset | undefined;
+/** Local server detection waits this long for each address. */
+declare const AI_LOCAL_DETECT_TIMEOUT_MS = 1500;
+/** What `detectLocalServers` is asked about: every local preset but Custom, at its default address. */
+declare function localDetectCandidates(presets?: readonly AiEnginePreset[]): {
+    presetId: string;
+    baseUrl: string;
+}[];
+
+/**
+ * Pure parsers for discovery responses, one per endpoint shape. Hosts do the
+ * HTTP and hand the parsed JSON here, so the VS Code adapters and the Rust
+ * port read the same fixtures (`test/ai-fixtures/discovery/`). Every parser
+ * tolerates junk: entries without a string id are skipped, never thrown on.
+ */
+
+/** `GET {base}/models` on any OpenAI-compatible server: ids only, capabilities from heuristics. */
+declare function parseOpenAiModelList(body: unknown): AiDiscoveredModel[];
+/**
+ * LM Studio `GET /api/v0/models`: `type` (`llm`, `vlm`, `embeddings`),
+ * `max_context_length`, `state` (`loaded` / `not-loaded`), `arch` (a `moe`
+ * in it marks a mixture of experts; one ending `_mtp` is a speculative-decoding
+ * drafter, not a chat model), and on newer builds `capabilities`
+ * (`tool_use`).
+ */
+declare function parseLmStudioModels(body: unknown): AiDiscoveredModel[];
+/**
+ * oMLX `GET {base}/models/status` (beside its OpenAI `/models`): per model
+ * `loaded` and `model_type` (`llm`, `vlm`, `embedding`, or a non-text type
+ * such as `audio_stt` or `markitdown`, which can neither chat nor embed),
+ * `model_context_length`, `estimated_size` (bytes) and `config_model_type`
+ * (a `moe` in it marks a mixture of experts; one ending `_mtp` is a
+ * speculative-decoding drafter, not a chat model, though it says `llm`).
+ */
+declare function parseOmlxModelStatus(body: unknown): AiDiscoveredModel[];
+/**
+ * Fold a status listing (`parseOmlxModelStatus`) into the models `/models`
+ * listed: the listing decides which models exist, the status adds what it
+ * knows about each (capabilities, loaded state).
+ */
+declare function withModelStatus(listed: readonly AiDiscoveredModel[], status: readonly AiDiscoveredModel[]): AiDiscoveredModel[];
+/**
+ * Sizes in bytes by model id from a listing that has them: LM Studio
+ * `GET /api/v1/models` (`models[].key`, `size_bytes`; its `/api/v0` has
+ * none) and Ollama `GET /api/tags` (`models[].model` or `name`, `size`).
+ */
+declare function parseModelSizes(body: unknown): Map<string, number>;
+/** `models` with the sizes `parseModelSizes` found added; the rest as they were. */
+declare function withModelSizes(models: readonly AiDiscoveredModel[], sizes: ReadonlyMap<string, number>): AiDiscoveredModel[];
+/** Ollama `GET /api/tags`: the model names to ask `/api/show` about. */
+declare function parseOllamaTags(body: unknown): string[];
+/**
+ * Ollama `POST /api/show` for one model: `capabilities` (`completion`,
+ * `vision`, `tools`, `embedding`, `insert`) and the context length under
+ * `model_info["<arch>.context_length"]`.
+ */
+declare function parseOllamaShow(name: string, body: unknown): AiDiscoveredModel;
+/** Which Ollama models are loaded right now, from `GET /api/ps` (optional). */
+declare function parseOllamaRunning(body: unknown): Set<string>;
+/**
+ * Anthropic `GET /v1/models`: `display_name`, `max_input_tokens` (the context
+ * window) and the `capabilities` tree (`image_input.supported`,
+ * `structured_outputs.supported`). Tools are assumed on.
+ */
+declare function parseAnthropicModels(body: unknown): AiDiscoveredModel[];
+/** Anthropic pages its list; the next `after_id`, or null on the last page. */
+declare function anthropicNextPage(body: unknown): string | null;
+/** The URL detection GETs: `detectPath` under the server root (no `/v1`), else `{baseUrl}/models`. */
+declare function localDetectUrl(baseUrl: string, detectPath?: string): string;
+/**
+ * How many models a detection answer lists: `data` (OpenAI-style, LM Studio)
+ * or `models` (Ollama). LM Studio's embedding models are left out. Undefined
+ * for a body of neither shape (the server answered, the count is unknown).
+ */
+declare function countDetectedModels(body: unknown): number | undefined;
+/** What a host needs to probe one detection candidate. */
+interface AiLocalDetectTarget {
+    presetId: string;
+    baseUrl: string;
+    /** The GET. */
+    url: string;
+    /** For the auth header shape. */
+    kind: AiEngineKind;
+    /** Where to read a key, only when `baseUrl` is the preset's own address. */
+    apiKeyEnv?: string;
+    apiKeyFile?: AiApiKeyFile;
+}
+/**
+ * A detection candidate checked against the presets. Null for an unknown or
+ * cloud preset, Custom, or an address that is not http(s). A key source
+ * (oMLX's key file) comes along only when the address is the preset's own,
+ * so a key never goes anywhere the user did not set up.
+ */
+declare function localDetectTarget(candidate: {
+    presetId: string;
+    baseUrl: string;
+}, presets?: readonly AiEnginePreset[]): AiLocalDetectTarget | null;
+
+/**
+ * The settings before the host sends any. Its own module so the editor can
+ * start from them without loading the rest of the AI layer (see `ai-lite.ts`).
+ */
+
+declare function defaultAiSettings(): AiSettings;
+
+/**
+ * Task routing: which engine and model serve a feature's request. Pure and
+ * cheap, so the editor recomputes it on every request from the settings, the
+ * status cache of the last `listEngines`, and the consent answers so far.
+ *
+ * 1. The master switch and the feature must be on.
+ * 2. Route = `routing.tasks[task]`, else `routing.default`.
+ * 3. A candidate is usable when the engine exists, is enabled and of a known
+ *    kind (a host kind such as `vscode-lm` only when the host lists a status
+ *    for it); the model exists, is enabled and not `missing`; the model has every
+ *    capability the task and feature need; the engine is local, or cloud with
+ *    `allowCloud` on and consent not refused; and its last probe did not fail.
+ * 4. Otherwise `routing.fallback`: `none` stops, `default` tries the default
+ *    route, `anyLocal` then every local engine/model in registry order, `any`
+ *    then cloud engines through the same gate. Fallback never moves a local
+ *    route to a cloud engine unless the mode is `any`.
+ * 5. The result names the pair and whether a fallback served it.
+ *
+ * A task may also `prefers` capabilities (JSON output for `structure`, a big
+ * context for `summarize`). That is never a rejection reason. The chosen
+ * route is honoured as is; when a fallback has several usable candidates in
+ * the same tier (the default route and the local engines, then the cloud
+ * ones), those meeting the preference come first, in registry order.
+ *
+ * Consent: a cloud candidate nobody has asked about yet is usable with
+ * `needsConsent: true`; the caller asks (`host.ai.requestCloudConsent`),
+ * records the answer and resolves again. A refusal (`false`) makes the
+ * engine unusable, which lets the fallback run.
+ */
+
+/** Consent answers by engine id: true granted, false refused ("Not now"), absent never asked. */
+type AiConsentState = Readonly<Record<string, boolean | undefined>>;
+type AiUnusableCode = 'aiDisabled' | 'featureDisabled' | 'noRoute' | 'engineMissing' | 'engineDisabled' | 'engineUnsupported' | 'modelMissing' | 'modelDisabled' | 'modelNotListed' | 'capability' | 'cloudBlocked' | 'consentDenied' | 'probeFailed';
+interface AiRouteOk {
+    engineId: string;
+    modelId: string;
+    viaFallback: boolean;
+    /** Why the preferred route was passed over, when `viaFallback`. */
+    reason?: string;
+    /** The task that was routed. */
+    task: string;
+    isLocal: boolean;
+    /** Cloud engine with no consent answer yet: ask before sending. */
+    needsConsent: boolean;
+}
+interface AiRouteUnusable {
+    unusable: AiUnusableCode;
+    /** Tooltip copy, e.g. "oMLX (Mac Studio) failed its last connection test". */
+    reason: string;
+    task?: string;
+    /** The engine the rejection is about (the routed one), when it is about one engine. */
+    engineId?: string;
+}
+type AiRouteResolution = AiRouteOk | AiRouteUnusable;
+declare function isRouteUsable(r: AiRouteResolution): r is AiRouteOk;
+interface ResolveRouteOptions {
+    feature: string;
+    /** Route this task instead of the feature's. */
+    task?: string;
+}
+declare function resolveRoute(settings: AiSettings, statuses: readonly AiEngineStatus[], consent: AiConsentState, opts: ResolveRouteOptions): AiRouteResolution;
+
+/**
+ * Server-sent events, reassembled from arbitrary network chunks (a line, or
+ * a multi-byte character, may be split across chunks; the host decodes bytes
+ * with a streaming `TextDecoder` before pushing text here), plus readers for
+ * the two completion stream shapes:
+ *
+ * - OpenAI Chat Completions (OpenAI, oMLX, LM Studio, Ollama `/v1`, vLLM,
+ *   llama.cpp): `data: {choices:[{delta:{content}}]}` chunks ending in
+ *   `data: [DONE]`. `reasoning_content` deltas are thinking, not text.
+ * - Anthropic Messages: `message_start`, `content_block_delta` with
+ *   `text_delta`, `message_delta` with `stop_reason` and usage, `message_stop`,
+ *   and an `error` event.
+ *
+ * A stream that ends without its terminator (`[DONE]` or `message_stop`) is
+ * truncated: `finishReason: 'error'`.
+ */
+
+interface SseEvent {
+    /** `event:` field; absent means the default `message`. */
+    event?: string;
+    data: string;
+    id?: string;
+}
+/** Incremental SSE parser (WHATWG event-stream rules: CRLF/CR/LF, `:` comments, multi-line `data`). */
+declare class SseParser {
+    private buffer;
+    private started;
+    private dataLines;
+    private eventName;
+    private lastId;
+    /** Feed decoded text; returns the events it completed. */
+    push(chunk: string): SseEvent[];
+    /** The stream closed: flush a final event that had no trailing blank line. */
+    end(): SseEvent[];
+    private line;
+}
+/** Where a completion stream ended up. */
+interface StreamOutcome {
+    text: string;
+    finishReason: AiFinishReason;
+    usage?: AiUsage;
+    /** The provider's own stop reason (`end_turn`, `length`, `refusal`...). */
+    stopReason?: string;
+    /** A stream-level error event, mapped to a code. */
+    error?: {
+        code: AiErrorCode;
+        message: string;
+    };
+}
+/** One completion stream: push decoded chunks, get text deltas back, then `finish`. */
+interface CompletionStreamReader {
+    push(chunk: string): string[];
+    finish(): StreamOutcome;
+    /**
+     * Output seen so far, answer plus reasoning, in UTF-16 units: above zero
+     * once the model starts generating (the host's first-token time), and the
+     * basis of a token estimate when the engine reports no usage.
+     */
+    outputChars(): number;
+}
+/** Chat Completions stream (`openai-compatible`, `lmstudio`, `ollama`, `openai`). */
+declare function createOpenAiStreamReader(): CompletionStreamReader;
+/** Anthropic Messages stream. */
+declare function createAnthropicStreamReader(): CompletionStreamReader;
+/** The reader for an engine kind. */
+declare function createCompletionStreamReader(kind: AiEngineKind): CompletionStreamReader;
+
+/**
+ * How long a result took and how fast it came: the popover footer's
+ * "2.4 s · 38 tok/s", its tooltip, and the hosts' request log. Hosts measure
+ * (`AiCompletionResult.timing`); this only does the arithmetic and the words.
+ *
+ * Output tokens are the engine's own count when it reports one (OpenAI-style
+ * `usage` with `stream_options.include_usage`, Anthropic `message_delta`),
+ * else about one token per four characters of output, marked approximate
+ * ("~38 tok/s"). Speed is output tokens over the time from the first token to
+ * the end; without a first-token time, over the whole request.
+ *
+ * Desktop's `request_log.rs` ports `aiTimingLogParts`; keep them in step.
+ */
+
+/** Characters per token for the estimate when the engine reports no usage. */
+declare const AI_CHARS_PER_TOKEN = 4;
+interface AiResultStats {
+    totalMs: number;
+    firstTokenMs?: number;
+    outputTokens?: number;
+    inputTokens?: number;
+    /** `outputTokens` (and so the speed) is estimated from the characters. */
+    approximate: boolean;
+    tokensPerSecond?: number;
+}
+/** The numbers behind the footer, or null when the host measured nothing (an older host). */
+declare function aiResultStats(result: Pick<AiCompletionResult, 'text' | 'usage' | 'timing'>): AiResultStats | null;
+/** "0.8 s", "2.4 s", "12 s". */
+declare function formatAiSeconds(ms: number): string;
+/** "38 tok/s", "~38 tok/s", "4.5 tok/s". */
+declare function formatAiTokensPerSecond(tps: number, approximate: boolean): string;
+/** The footer text: "2.4 s · 38 tok/s", or just "2.4 s" with no speed. */
+declare function aiResultStatsText(stats: AiResultStats): string;
+/** The footer tooltip, one fact per line. */
+declare function aiResultStatsTitle(stats: AiResultStats): string;
+/** The request log's additions: `first token N ms` and the speed, when measured. */
+declare function aiTimingLogParts(result: Pick<AiCompletionResult, 'text' | 'usage' | 'timing'>): string[];
+
+/**
+ * Request building per engine kind: endpoint URLs, auth headers and the
+ * completion and embedding bodies. Pure, so the VS Code adapters and the Rust
+ * port produce identical requests (checked against the same fixtures).
+ *
+ * Bodies:
+ * - Chat Completions kinds: `{ model, messages, stream, max_tokens,
+ *   temperature, response_format }`; `openai` uses `max_completion_tokens`
+ *   and asks for usage in the stream. OpenAI reasoning models (o-series,
+ *   GPT-5 onwards) get no `temperature`: they accept only the default.
+ * - `anthropic`: Messages API, system prompts lifted into `system`,
+ *   `max_tokens` always set (required). No sampling parameters: API version
+ *   2026-10-21 rejects `temperature`.
+ *
+ * `model.requestOverrides` merge last, deeply (objects merge, everything else
+ * replaces), so they win (OPEN-6); then the request's own `requestOverrides`
+ * (a per-request thinking level) merge over those the same way.
+ *
+ * A 400 that names a parameter the model does not take
+ * (`unsupportedRequestParam`) is retried once without it
+ * (`withoutRequestParam`); the hosts remember it per engine and model for
+ * the session.
+ */
+
+/** `anthropic-version` sent by the Anthropic adapter. */
+declare const ANTHROPIC_API_VERSION = "2026-10-21";
+/** `max_tokens` for Anthropic when the request sets none (the API requires it). */
+declare const ANTHROPIC_DEFAULT_MAX_TOKENS = 4096;
+/** Appended to the system prompt for `format: 'json'` on kinds with no schema-free JSON mode. */
+declare const JSON_ONLY_INSTRUCTION = "Respond with a single valid JSON value and nothing else.";
+type Json$1 = Record<string, unknown>;
+interface AiEngineEndpoints {
+    /** Streaming completion. */
+    completions: string;
+    /** Model list used for Test connection and bare discovery. */
+    models: string;
+    /** Embeddings, absent for kinds without them. */
+    embeddings?: string;
+    /** Native discovery endpoint (LM Studio `/api/v0/models`, Ollama `/api/tags`). */
+    nativeModels?: string;
+    /** Ollama `POST /api/show` (body `{ model }`). */
+    nativeShow?: string;
+}
+/**
+ * URLs for an engine. OpenAI-style base URLs include `/v1`
+ * (`http://127.0.0.1:8000/v1`); for LM Studio and Ollama a base without it
+ * gets `/v1` added for completions, and their native endpoints hang off the
+ * root. Anthropic's base is the host (`https://api.anthropic.com`), with or
+ * without `/v1`.
+ */
+declare function engineEndpoints(engine: Pick<AiEngineConfig, 'kind' | 'baseUrl'>): AiEngineEndpoints;
+/** Headers for every request to the engine (JSON content type included). */
+declare function buildAuthHeaders(kind: AiEngineKind, apiKey: string | null): Record<string, string>;
+/** Deep merge: nested plain objects merge, anything else in `overrides` replaces. Inputs are not mutated. */
+declare function mergeRequestOverrides(body: Json$1, overrides: Json$1 | undefined): Json$1;
+/** Standard base64 with padding, no line breaks. No `Buffer` or `btoa`, so it runs in every host. */
+declare function bytesToBase64(bytes: Uint8Array): string;
+/** Inverse of `bytesToBase64`; ignores whitespace and accepts URL-safe characters. */
+declare function base64ToBytes(b64: string): Uint8Array;
+interface BuildCompletionOptions {
+    /** Default true. */
+    stream?: boolean;
+}
+/** The JSON body for one completion against `model` on an engine of `kind`. */
+declare function buildCompletionBody(kind: AiEngineKind, model: Pick<AiModelConfig, 'id' | 'requestOverrides'>, req: AiCompletionRequest, opts?: BuildCompletionOptions): Json$1;
+/**
+ * Cloud hosts of the `openai-compatible` kind that take
+ * `stream_options.include_usage` (OpenRouter, Gemini, Groq, DeepSeek).
+ * Mistral and unknown cloud hosts are left out: a strict server may reject
+ * a field it does not know.
+ */
+declare const STREAM_USAGE_HOSTS: readonly string[];
+/**
+ * Whether a streamed completion may ask for usage in the stream. `openai`,
+ * LM Studio and Ollama take it; on `openai-compatible`, a server on this
+ * machine or network (oMLX, vLLM, llama.cpp all take it) or a host in
+ * `STREAM_USAGE_HOSTS`. Anthropic reports usage without being asked.
+ */
+declare function streamUsageSupported(engine: Pick<AiEngineConfig, 'kind' | 'baseUrl'>): boolean;
+/**
+ * `body` asking for usage in the stream (`stream_options.include_usage`)
+ * when the engine takes it, the body streams and the overrides did not set
+ * `stream_options` themselves. Hosts apply it after `buildCompletionBody`.
+ */
+declare function withStreamUsage(body: Json$1, engine: Pick<AiEngineConfig, 'kind' | 'baseUrl'>): Json$1;
+/**
+ * Body fields a server may reject for one model while taking them for
+ * others. Only these are retried: anything else in a 400 is a real error.
+ */
+declare const RETRYABLE_REQUEST_PARAMS: readonly string[];
+/**
+ * The parameter a failed completion was rejected for, or null. Only a 400
+ * whose error says the parameter (or its value) is unsupported counts:
+ * OpenAI's `{ error: { param, code: "unsupported_value" | "unsupported_parameter", message } }`,
+ * or any body whose message quotes one of `RETRYABLE_REQUEST_PARAMS` next to
+ * that wording (the first one quoted, so "Use 'max_completion_tokens'
+ * instead" does not count).
+ */
+declare function unsupportedRequestParam(status: number, bodyText: string): string | null;
+/**
+ * `body` without a parameter the server rejected: `max_tokens` and
+ * `max_completion_tokens` become each other (the documented replacement),
+ * anything else is dropped. Null when the body does not carry it, so there
+ * is nothing to retry.
+ */
+declare function withoutRequestParam(body: Json$1, param: string): Json$1 | null;
+/** Embeddings body (`POST .../embeddings`), or null for kinds without an embeddings endpoint. */
+declare function buildEmbeddingsBody(kind: AiEngineKind, model: Pick<AiModelConfig, 'id' | 'requestOverrides'>, texts: string[]): Json$1 | null;
+/** Vectors from an OpenAI-style embeddings response, in input order. */
+declare function parseEmbeddingsResponse(body: unknown): number[][];
+
+/**
+ * `AiCompletionRequest` over a JSON channel (VS Code `postMessage`, Tauri
+ * `invoke`): image bytes travel as base64, the same way `savePastedImage`
+ * sends pasted images.
+ */
+
+type AiWireMessagePart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    mime: string;
+    dataBase64: string;
+};
+interface AiWireMessage {
+    role: AiMessage['role'];
+    content: string | AiWireMessagePart[];
+}
+type AiWireCompletionRequest = Omit<AiCompletionRequest, 'messages'> & {
+    messages: AiWireMessage[];
+};
+declare function toWireCompletionRequest(req: AiCompletionRequest): AiWireCompletionRequest;
+declare function fromWireCompletionRequest(wire: AiWireCompletionRequest): AiCompletionRequest;
+
+/**
+ * `AiError` helpers and the user-facing copy for each `AiErrorCode`, kept in
+ * one place so the rewrite popover, the AI tab and the indicator say the same
+ * thing. Hosts reject with `{ code, message }`; `message` is the technical
+ * detail, the copy here is what the user reads first.
+ */
+
+interface AiErrorCopy {
+    title: string;
+    message: string;
+    /**
+     * Suggested next step, when there is one. `openEngine`: the failing
+     * engine's own page. `chooseModel`: the same page, to pick another model.
+     */
+    action?: 'openSettings' | 'openEngine' | 'chooseModel' | 'retry' | 'shortenSelection';
+}
+declare const AI_ERROR_COPY: Readonly<Record<AiErrorCode, AiErrorCopy>>;
+/**
+ * A stream that stopped at its token limit (`finishReason: 'length'`). A
+ * thinking model counts its reasoning against that limit, so with thinking
+ * on the advice is to lower Thinking. `empty`: no answer text came back at
+ * all (shown as the error); otherwise the answer is shown with `message` as
+ * a note.
+ */
+declare function aiLengthLimitCopy(opts: {
+    thinking: boolean;
+    empty: boolean;
+}): AiErrorCopy;
+declare function isAiErrorCode(v: unknown): v is AiErrorCode;
+declare function isAiError(v: unknown): v is AiError;
+declare function makeAiError(code: AiErrorCode, message?: string): AiError;
+/** Any rejection value as an `AiError`: an `AiError` as is, an `AbortError` as `cancelled`, the rest `unknown`. */
+declare function toAiError(err: unknown): AiError;
+/**
+ * The copy for `code`. With `engine` (the display name of the engine the
+ * request went to), an engine problem names it and its action is
+ * `openEngine` (`chooseModel` for a model that did not load): the popover's
+ * button opens that engine instead of the AI tab. `model` names the model
+ * where the copy has room for it.
+ */
+declare function aiErrorCopy(code: AiErrorCode, opts?: {
+    engine?: string;
+    model?: string;
+}): AiErrorCopy;
+/**
+ * A local server that could not load the model: LM Studio's `Failed to load
+ * model "x"`, llama.cpp's `error loading model`, Ollama's `llama runner
+ * process has terminated` and its out-of-memory refusal.
+ */
+declare const MODEL_LOAD_FAILED_PHRASES: readonly string[];
+/**
+ * Map an HTTP failure to a code (shared by both hosts): 401/403 auth, 404
+ * modelNotFound, a body that says the model failed to load modelLoadFailed,
+ * 413 or a 400 that mentions the context contextOverflow, 429 and 529
+ * rateLimited, 502/503/504 unreachable, everything else unknown.
+ */
+declare function aiErrorCodeFromHttp(status: number, bodyText?: string): AiErrorCode;
+
+/**
+ * Per-model thinking level (Off / Low / Medium / High) mapped onto each
+ * engine kind's request fields, stored in the model's `requestOverrides`
+ * (OPEN-6) so the adapters need no change: they merge the overrides into
+ * every request body last.
+ *
+ * Mappings:
+ * - `openai` and cloud `openai-compatible` (Gemini, Groq, OpenRouter...):
+ *   `reasoning_effort` `none` / `low` / `medium` / `high`. Off is stored as
+ *   `none`; `buildCompletionBody` swaps it for the lowest value an OpenAI
+ *   reasoning model accepts (`openAiOffReasoningEffort`).
+ * - local `openai-compatible` (oMLX, vLLM, llama.cpp): tiers through
+ *   `reasoning_effort`; Off through `chat_template_kwargs.enable_thinking:
+ *   false`, which the chat template honours (oMLX ignores
+ *   `reasoning_effort: "none"`).
+ * - `lmstudio`: on/off only, `reasoning_effort` `none` or `medium`.
+ * - `ollama`: `reasoning_effort` `none` / `low` / `medium` / `high` (its
+ *   OpenAI-compatible endpoint maps it onto `think`).
+ * - `vscode-lm`: none (VS Code's language model API has no such field).
+ * - `anthropic`: adaptive thinking with `output_config.effort` `low` /
+ *   `medium` / `high`. No Off: current models reject `thinking: disabled`
+ *   (Opus 5.5, Sonnet 5.5, Fable), so Low is the lightest setting.
+ *
+ * "Model default" (no level) removes the kind's thinking fields and leaves
+ * everything else in `requestOverrides` alone.
+ *
+ * Per-task default (Q6): with the dial on Default and no level set on the
+ * model, MikeDown picks the level for the job (`taskThinkingDefault`): Off
+ * for the short edits (every rewrite variant, translate, suggest title,
+ * suggest properties), none for the rest (explain, summarize), so the model
+ * decides there. An explicit dial choice, or a level set on the model, wins
+ * (`resolveThinkingLevel`).
+ */
+type AiThinkingLevel = 'off' | 'low' | 'medium' | 'high';
+interface AiThinkingChoice {
+    level: AiThinkingLevel;
+    label: string;
+}
+interface AiThinkingOptions {
+    /** The engine's locality is local (changes the Off mapping for `openai-compatible`). */
+    local?: boolean;
+}
+type Json = Record<string, unknown>;
+/** The levels a kind can express, in order. Empty means no known mapping: hide the control. */
+declare function thinkingChoices(kind: string): AiThinkingChoice[];
+/**
+ * The level a kind uses for `level`: the level itself when the kind has it,
+ * else the nearest one (Off on Anthropic is Low, any tier on LM Studio is
+ * On). Null for no level or a kind with no mapping.
+ */
+declare function nearestThinkingLevel(kind: string, level: AiThinkingLevel | null): AiThinkingLevel | null;
+/**
+ * What a request is for, as far as its default thinking level goes: a
+ * feature id (`rewrite`, `title`, `frontmatter`, `summary`) or a job that
+ * shares one (`explain` and `translate` run under `rewrite`).
+ */
+type AiThinkingJob = string;
+/**
+ * The level MikeDown picks for a job when the dial is on Default (Q6): Off
+ * for the short edits, null (the model's own) for everything else.
+ */
+declare function taskThinkingDefault(job: string | undefined): AiThinkingLevel | null;
+interface ResolvedThinkingLevel {
+    /** The level to send (already the kind's nearest), or null to send none. */
+    level: AiThinkingLevel | null;
+    /** True when `level` is the job's default rather than the user's choice. */
+    auto: boolean;
+}
+/**
+ * The level a request sends: the user's explicit choice (the dial) first,
+ * then nothing when the model has its own level set (`configured`), then the
+ * job's default (mapped to the kind's nearest: Off on Anthropic is Low).
+ * The explicit level is sent as given (`thinkingLevelFor` already maps a
+ * remembered one); one the kind cannot express sends nothing.
+ */
+declare function resolveThinkingLevel(kind: string, explicit: AiThinkingLevel | null, configured: AiThinkingLevel | null, job: string | undefined, opts?: {
+    modelId?: string;
+}): ResolvedThinkingLevel;
+/** The request fields for one level, or `{}` when the kind cannot express it. */
+declare function thinkingOverrides(kind: string, level: AiThinkingLevel, opts?: AiThinkingOptions): Json;
+/** The level `overrides` express for this kind, or null for "model default" (or a value the menu has no entry for). */
+declare function thinkingLevelFrom(kind: string, overrides: Json | undefined): AiThinkingLevel | null;
+/**
+ * `requestOverrides` with the thinking level set (null: model default).
+ * Other keys, nested ones included, are kept. Undefined when nothing is left.
+ */
+declare function withThinkingLevel(kind: string, overrides: Json | undefined, level: AiThinkingLevel | null, opts?: AiThinkingOptions): Json | undefined;
+/**
+ * Output tokens a thinking model may spend reasoning before it answers, by
+ * level. A thinking model counts its reasoning against `max_tokens`, so an
+ * answer budget alone can be used up before the first visible word. Sized
+ * for local reasoning models (Qwen3 class), which often think 2,000 to
+ * 4,000 tokens even on a one-paragraph edit. It is a ceiling, not a spend.
+ */
+declare const THINKING_HEADROOM_TOKENS: Readonly<Record<AiThinkingLevel, number>>;
+/** "Model default" (no level set): the model may think, at a level we cannot see. */
+declare const THINKING_DEFAULT_HEADROOM_TOKENS: number;
+/** The most `thinkingMaxTokens` raises a request to (a larger answer budget is kept as is). */
+declare const THINKING_MAX_TOKENS_CAP = 12288;
+interface ThinkingBudgetOptions {
+    /** The model's context window, when known. */
+    contextTokens?: number | null;
+    /** Estimated prompt tokens; with `contextTokens`, the headroom never pushes past the window. */
+    promptTokens?: number;
+}
+/**
+ * The `max_tokens` to send for an answer budget of `answerTokens` on a model
+ * that can think: the answer plus reasoning headroom for the effective level
+ * (null: model default, counted as thinking). Off adds nothing. The raise is
+ * capped at `THINKING_MAX_TOKENS_CAP` and at what is left of the context
+ * window, and never goes below the answer budget.
+ */
+declare function thinkingMaxTokens(answerTokens: number, level: AiThinkingLevel | null, opts?: ThinkingBudgetOptions): number;
+
+/**
+ * Selection rewrite prompt (the `rewrite` feature). Pure: builds the chat
+ * messages from the selected markdown and a little context, and cleans what
+ * the model sends back before it is previewed or parsed into the document.
+ *
+ * Context budget (brainstorm constraint 8): the selection plus the text of
+ * the enclosing block before and after it, and the neighbouring block on each
+ * side, capped at `REWRITE_CONTEXT_CHARS` per side. Never the whole document.
+ */
+
+type AiRewriteVariant = 'shorter' | 'longer' | 'expand' | 'simpler' | 'fixFlow' | 'formal' | 'casual' | 'readingLevel' | 'translate' | 'explain' | 'custom';
+/** Menu group a variant belongs to (the popover's choose phase renders one section per group). */
+type AiRewriteGroup = 'length' | 'tone' | 'audience' | 'translate' | 'explain' | 'custom';
+/** `replace` swaps the selection; `readOnly` only shows text (Explain) and can insert it below. */
+type AiRewriteOutput = 'replace' | 'readOnly';
+type AiAudience = 'general' | 'expert' | 'plain' | 'grade8' | 'esl';
+interface AiAudienceDefinition {
+    id: AiAudience;
+    label: string;
+    /** Instruction line sent to the model for `readingLevel`. */
+    instruction: string;
+}
+declare const AI_AUDIENCES: readonly AiAudienceDefinition[];
+declare function getAiAudience(id: string): AiAudienceDefinition | undefined;
+interface AiRewriteVariantDefinition {
+    id: AiRewriteVariant;
+    /** Menu label. */
+    label: string;
+    /** Tooltip, where the label alone does not tell two variants apart (Longer, Add detail). */
+    title?: string;
+    /**
+     * The instruction line sent to the model. Empty for `custom` (the user's own
+     * words); `{language}` and `{audience}` are filled from `RewritePromptInput.params`.
+     */
+    instruction: string;
+    group: AiRewriteGroup;
+    output: AiRewriteOutput;
+    /** The parameter this variant needs before it can run (a second-level picker supplies it). */
+    param?: 'language' | 'audience';
+}
+/** Order here is the menu order. */
+declare const AI_REWRITE_VARIANTS: readonly AiRewriteVariantDefinition[];
+declare function getAiRewriteVariant(id: string): AiRewriteVariantDefinition | undefined;
+/** Context kept on each side of the selection, in characters (about 400 tokens). */
+declare const REWRITE_CONTEXT_CHARS = 1600;
+/** Longest custom instruction sent as is. */
+declare const REWRITE_INSTRUCTION_MAX_CHARS = 1000;
+interface RewritePromptInput {
+    variant: AiRewriteVariant;
+    /** The user's instruction for `custom` (ignored otherwise). */
+    instruction?: string;
+    /** The selected text as markdown. */
+    selection: string;
+    /** Markdown just before the selection (enclosing block, then the previous one). */
+    before?: string;
+    /** Markdown just after the selection. */
+    after?: string;
+    /** Values for the parameterised variants (`translate` needs `language`, `readingLevel` needs `audience`). */
+    params?: AiRewriteParams;
+    /**
+     * `document` for a whole-document run (`translate`): the passage is the body
+     * without its frontmatter and no context is sent. Default `selection`.
+     */
+    scope?: AiRewriteScope;
+}
+interface AiRewriteParams {
+    language?: string;
+    audience?: AiAudience;
+}
+type AiRewriteScope = 'selection' | 'document';
+/** Longest target language name sent (it is free text from "Other…"). */
+declare const REWRITE_LANGUAGE_MAX_CHARS = 60;
+declare const REWRITE_SYSTEM_PROMPT: string;
+/**
+ * Appended to the system prompt for `translate`. It overrides the "write in the
+ * language of the passage" rule; the target language is named only in the
+ * instruction line.
+ */
+declare const TRANSLATE_SYSTEM_ADDENDUM: string;
+/** Appended to the system prompt when the instruction asks for an explanation (the `explain` variant). */
+declare const EXPLAIN_SYSTEM_ADDENDUM = "The instruction asks for an explanation of the passage, not a version of it: the \"version of the passage\" rules above do not apply. Reply with the explanation only, as Markdown prose, and do not repeat the passage.";
+/** The whole-document variant of the translation note. */
+declare const TRANSLATE_DOCUMENT_NOTE = "The passage is a whole document body (its frontmatter has been removed and is handled elsewhere). Translate all of it, from the first line to the last.";
+/** Neutralise a closing tag inside user text so it cannot end its block early. */
+declare function escapeClosingTag(text: string, tag: string): string;
+/** Context trimmed to the budget at the far end, so the part next to the selection survives. */
+declare function trimRewriteContext(text: string, side: 'before' | 'after', max?: number): string;
+/** Target language as typed, flattened to one short line (it ends up inside a prompt). */
+declare function normalizeRewriteLanguage(language: string | undefined): string;
+/**
+ * The instruction line for a variant. A parameterised variant whose parameter
+ * is missing or unknown falls back to `fixFlow`, like an empty `custom`.
+ */
+declare function rewriteInstruction(input: Pick<RewritePromptInput, 'variant' | 'instruction' | 'params'>): string;
+/** The system prompt for a variant: the shared rules plus the translate or explain addendum. */
+declare function rewriteSystemPrompt(variant: AiRewriteVariant, scope?: AiRewriteScope): string;
+declare function buildRewriteMessages(input: RewritePromptInput): AiMessage[];
+/** Output budget for `explain`: a short note, independent of the passage length. */
+declare const EXPLAIN_MAX_TOKENS = 600;
+/** Output budget: room for "longer" to double the passage, never below a short paragraph. */
+declare function rewriteMaxTokens(selection: string, variant: AiRewriteVariant): number;
+/**
+ * The text to show while it streams: reasoning blocks (`<think>…</think>`,
+ * which some local models put in the content) are hidden, including one that
+ * has not closed yet, and an echoed `<passage>` tag is dropped.
+ */
+declare function rewriteVisibleText(raw: string): string;
+/**
+ * The final replacement: the visible text without a wrapping code fence or
+ * quotes the model added, trimmed, with the selection's own leading and
+ * trailing whitespace put back (a selection of "word " stays one word plus a
+ * space).
+ */
+declare function finalizeRewriteText(raw: string, selection: string): string;
+
+/**
+ * Explain prompt (the `explain` variant of the `rewrite` feature). Pure: builds
+ * the chat messages for a read-only note about the selected passage. The reply
+ * is shown in the popover and can be inserted below the selection; it never
+ * replaces anything.
+ */
+
+declare const EXPLAIN_SYSTEM_PROMPT: string;
+interface ExplainPromptInput {
+    /** The selected text as markdown. */
+    selection: string;
+    /** Markdown just before the selection. */
+    before?: string;
+    /** Markdown just after the selection. */
+    after?: string;
+    /** The document title (frontmatter `title:` or the first heading), if there is one. */
+    title?: string;
+}
+declare function buildExplainMessages(input: ExplainPromptInput): AiMessage[];
+/** Output budget: a short note whatever the passage length. */
+declare function explainMaxTokens(): number;
+
+/**
+ * Markdown structure post-check. Pure: counts the structural pieces of a
+ * passage and compares the original with a model's result, so translate and
+ * tone rewrites can show a warning line before Accept when something was
+ * dropped. A warning only; it never blocks Accept.
+ */
+interface StructureCounts {
+    /** Headings by level, index 0 is level 1. */
+    headings: [number, number, number, number, number, number];
+    fencedCodeBlocks: number;
+    inlineCodeSpans: number;
+    /** URL of every link (inline, reference definition, autolink), in order. */
+    links: string[];
+    /** URL of every image, in order. */
+    images: string[];
+    listItems: number;
+    tableRows: number;
+    wikilinks: number;
+    footnoteReferences: number;
+}
+interface StructureMismatch {
+    kind: 'heading' | 'fencedCodeBlock' | 'inlineCode' | 'link' | 'image' | 'listItem' | 'tableRow' | 'wikilink' | 'footnote';
+    original: number;
+    result: number;
+    /** A human sentence such as "2 links in the original, 1 in the result". */
+    message: string;
+}
+interface StructureDiff {
+    /** True when nothing differs. */
+    ok: boolean;
+    mismatches: StructureMismatch[];
+    /** `mismatches[].message`, ready to show. */
+    messages: string[];
+}
+declare function countMarkdownStructure(markdown: string): StructureCounts;
+/**
+ * Compare the structure of a rewritten passage with the original. Zero
+ * mismatches means every counted piece survived; a mismatch is a sentence for
+ * the warning line, not an error.
+ */
+declare function checkMarkdownStructure(original: string, result: string): StructureDiff;
+
+/**
+ * Lenient JSON for local models (D6). Many local models have no JSON mode, so
+ * a reply can arrive as clean JSON, inside a code fence, after a sentence of
+ * prose, behind a `<think>` block, with a trailing comma or with single
+ * quotes. `parseLenientJson` takes all of those; plain text is `ok: false`
+ * with a message the repair turn can quote. Pure, no DOM.
+ */
+
+type LenientJsonResult<T = unknown> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Strip `<think>`, look inside code fences, take the first balanced `{…}` or
+ * `[…]` that parses (after one repair pass for the common slips) and return
+ * it. A reply with no JSON, or one cut off before it closed, is `ok: false`.
+ * `T` is only the caller's claim about the shape; validate before trusting it.
+ */
+declare function parseLenientJson<T = unknown>(raw: string): LenientJsonResult<T>;
+/**
+ * The one-shot repair turn: append these two messages to the original ones
+ * and ask again. The failed reply goes back as the assistant turn (reasoning
+ * removed, capped), then the parse error.
+ */
+declare function jsonRepairMessages(previousRaw: string, error: string): AiMessage[];
+/**
+ * The prompt line that fixes the reply shape: a one-line example object.
+ * Pass the example as a value (serialised on one line) or as a string.
+ */
+declare function JSON_SHAPE_HINT(example: unknown): string;
+
+/**
+ * Fit a markdown document to a model's context window by whole sections, and
+ * say how much of it fit (never a silent cut). Used by `/summary`, `/title`
+ * and Properties suggestions. Pure, no DOM.
+ *
+ * The kept text is always a prefix of the document: the frontmatter and the
+ * opening sections, ending on a heading boundary. If even the first section
+ * is too big it is cut on a blank line between blocks. A fenced code block is
+ * never split, so a fence that opens inside the kept text also closes in it.
+ */
+/** Characters per token the budget assumes (a little pessimistic for English). */
+declare const CHARS_PER_TOKEN = 3.5;
+interface DocumentBudgetOptions {
+    /** The model's context window in tokens. */
+    contextTokens: number;
+    /** Tokens the answer may use. */
+    outputTokens: number;
+    /** Tokens for the system prompt, instructions and slack. */
+    reserveTokens: number;
+}
+interface BudgetedDocument {
+    /** The markdown to send: frontmatter plus the leading sections that fit. */
+    text: string;
+    /** Share of the document in `text`, 0 to 1 (1 when nothing was cut). */
+    coverage: number;
+    truncated: boolean;
+    /** Sections in `text` (a partly kept first section counts as one). */
+    sectionsIncluded: number;
+    sectionsTotal: number;
+}
+interface HeadingOutlineEntry {
+    /** 1 to 6. */
+    level: number;
+    text: string;
+}
+/** Heading levels and texts, skipping frontmatter and fenced code. */
+declare function headingsOutline(markdown: string): HeadingOutlineEntry[];
+/**
+ * Keep the frontmatter and as many whole leading sections as fit in
+ * `contextTokens - outputTokens - reserveTokens` (at `CHARS_PER_TOKEN`
+ * characters a token). A first section bigger than the budget is cut on a
+ * block boundary instead, and the first block is kept whatever the budget.
+ */
+declare function budgetDocument(markdown: string, opts: DocumentBudgetOptions): BudgetedDocument;
+
+/**
+ * Summary prompts (the `summary` feature: `/summary` and `/outline`). Pure:
+ * builds the chat messages from the budgeted document and tidies the reply
+ * before it is previewed and inserted.
+ *
+ * TL;DR is wrapped in a `[!NOTE]` callout whose first line is **Summary**
+ * (D11: the GFM five are the only kinds that round-trip on GitHub). Outline
+ * stays a plain nested list.
+ */
+
+type AiSummaryKind = 'tldr' | 'outline';
+interface SummaryPromptInput {
+    /** The document as markdown, already through `budgetDocument`. */
+    document: string;
+    kind: AiSummaryKind;
+    /** Share of the document included, 0 to 1 (below 1 means it was cut). */
+    coverage: number;
+}
+/** A document shorter than this gets a one-paragraph TL;DR instead of bullets. */
+declare const SUMMARY_SHORT_DOCUMENT_CHARS = 1200;
+declare const SUMMARY_SYSTEM_PROMPT: string;
+declare const OUTLINE_SYSTEM_PROMPT: string;
+declare function coveragePercent(coverage: number): number;
+declare function buildSummaryMessages(input: SummaryPromptInput): AiMessage[];
+/** Output budget: scales with the input, within a range a small model handles. */
+declare function summaryMaxTokens(kind: AiSummaryKind, inputChars: number): number;
+/** The text to show while it streams (reasoning hidden). */
+declare function summaryVisibleText(raw: string): string;
+/**
+ * The preview once the stream ends: the body `finalizeSummary` will insert,
+ * without the callout wrapper and the coverage line (the popover shows those
+ * apart), so the cut fragment and lead-in are gone before Insert.
+ */
+declare function summaryPreviewText(raw: string, kind: AiSummaryKind, cutOff?: boolean): string;
+/**
+ * The markdown to insert. TL;DR becomes a `[!NOTE]` callout headed
+ * **Summary**; Outline stays the list. When the document was cut
+ * (`coverage` below 1) a "Covers the first N% of the document." line closes
+ * it. An empty reply stays empty so the caller can report a bad output.
+ * `cutOff` (the stream stopped at the length limit) drops a trailing
+ * fragment and ends the text with an ellipsis.
+ */
+declare function finalizeSummary(raw: string, kind: AiSummaryKind, coverage?: number, cutOff?: boolean): string;
+
+/**
+ * Title suggestions (`/title` and "Suggest titles…", the `title` feature).
+ * Pure: the prompt asks for a small JSON object, `parseTitles` validates it.
+ * The document is the budgeted prefix plus the full headings list, so a long
+ * document is still judged as a whole.
+ */
+
+declare const TITLE_MAX_CHARS = 120;
+/** Longest headings list sent, so a huge outline cannot eat the budget. */
+declare const TITLE_OUTLINE_MAX_ITEMS = 60;
+interface TitlePromptInput {
+    /** The document as markdown, already through `budgetDocument`. */
+    document: string;
+    /** All headings of the full document (not only the budgeted part). */
+    outline: readonly HeadingOutlineEntry[];
+    /** The current title, so the model does not hand it back. */
+    existingTitle?: string;
+    count?: number;
+}
+declare const TITLE_SYSTEM_PROMPT: string;
+/** The headings as an indented list, capped. Shared by the title and properties prompts. */
+declare function renderHeadingOutline(outline: readonly HeadingOutlineEntry[], max?: number): string;
+declare function buildTitleMessages(input: TitlePromptInput): AiMessage[];
+/** Output budget: a few short strings. */
+declare function titleMaxTokens(count?: number): number;
+type ParsedTitles = {
+    ok: true;
+    titles: string[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The titles in a reply: `{ "titles": [...] }` (a bare array or a single
+ * `title` string is accepted too), trimmed to 120 characters, de-duplicated
+ * case-insensitively, minus the existing title. No usable title is a failure
+ * so the caller can repair or report `badOutput`.
+ */
+declare function parseTitles(raw: string, existingTitle?: string): ParsedTitles;
+
+interface ParsedEntry {
+    key: string;
+    /** Scalar string, or array of strings (for `tags: [a, b]`-style). */
+    value: string | string[];
+}
+
+/**
+ * Properties suggestions (the `frontmatter` feature: "Suggest" in the
+ * sidebar's Properties header). Pure: the prompt asks for a title, a
+ * description and tags as JSON; `parsePropertySuggestions` validates the
+ * reply and normalises tags through the shared tag syntax, so what reaches the
+ * UI is already safe to apply.
+ */
+
+/** A frontmatter property as the sidebar holds it. */
+type AiFrontmatterEntry = ParsedEntry;
+declare const PROPERTY_MAX_TAGS = 8;
+declare const PROPERTY_DESCRIPTION_MAX_CHARS = 200;
+declare const PROPERTY_TITLE_MAX_CHARS = 120;
+/** Vocabulary tags listed in the prompt at most. */
+declare const PROPERTY_VOCABULARY_MAX = 80;
+interface PropertiesPromptInput {
+    /** The document as markdown, already through `budgetDocument`. */
+    document: string;
+    /** All headings of the full document. */
+    outline: readonly HeadingOutlineEntry[];
+    /** The properties the document already has. */
+    existing: readonly AiFrontmatterEntry[];
+    /** Tags used elsewhere in the workspace, most used first. */
+    vocabulary: readonly string[];
+}
+declare const PROPERTIES_SYSTEM_PROMPT: string;
+/** The tags the entries already carry, normalised (`tags:` or `tag:`, array or comma list). */
+declare function existingTagsOf(existing: readonly AiFrontmatterEntry[]): string[];
+declare function buildPropertiesMessages(input: PropertiesPromptInput): AiMessage[];
+/** Output budget: three short fields. */
+declare function propertiesMaxTokens(): number;
+interface SuggestedTag {
+    /** Normalised: lowercase, no `#`. */
+    tag: string;
+    /** Already used somewhere in the workspace (it is in the vocabulary). */
+    known: boolean;
+}
+interface PropertySuggestions {
+    title?: string;
+    description?: string;
+    tags: SuggestedTag[];
+}
+type ParsedPropertySuggestions = {
+    ok: true;
+    suggestions: PropertySuggestions;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Validate a reply: title and description trimmed to length and dropped when
+ * empty or equal to what the document has, tags normalised, marked `known`
+ * from the vocabulary, minus tags already present, de-duplicated and capped at
+ * 8. A reply with no title, description or tag at all is a failure; one whose
+ * suggestions are all already present succeeds with nothing left in it.
+ */
+declare function parsePropertySuggestions(raw: string, existing: readonly AiFrontmatterEntry[], vocabulary: readonly string[]): ParsedPropertySuggestions;
+
+/**
+ * Privacy copy for cloud engines: the four lines every surface shows (the
+ * privacy card, the disclaimer, the consent dialogs), what each feature
+ * sends, each provider's policy link, and the consent dialog text both hosts
+ * render (VS Code's modal, Desktop's native dialog; Desktop has a Rust port
+ * checked against `test/ai-fixtures/consent/`).
+ *
+ * No claims about any provider's training or retention: those are set by the
+ * provider's terms and change. The copy says "may" and points at the policy.
+ */
+
+/** The four lines of the privacy card, in display order. */
+declare const AI_CLOUD_PRIVACY: {
+    readonly leaves: "Text you ask about is sent over the internet to the provider and processed on their servers.";
+    readonly terms: string;
+    readonly local: "A local engine keeps everything on this machine or your network.";
+    readonly keys: "Your API key stays in this app's secure storage on this machine.";
+};
+/**
+ * The privacy card's lines for an engine built into the host (VS Code's
+ * Copilot models, `vscode-lm`): no API key, and the text goes through the
+ * host to GitHub's Copilot service under the user's Copilot plan. No claim
+ * about how a plan handles it; the policy link says.
+ */
+declare const AI_HOST_PRIVACY: {
+    readonly leaves: "Text you ask about goes through VS Code to GitHub’s Copilot service and is processed on GitHub’s servers, under your Copilot plan.";
+    readonly terms: "Whether it is retained or used for training is set by your plan’s terms, which differ between individual and business plans and may change; read them before you decide.";
+    readonly local: "A local engine keeps everything on this machine or your network.";
+    readonly permission: "VS Code also asks for its own permission the first time MikeDown uses Copilot.";
+};
+/**
+ * The sentence about the consent step, for the cloud privacy card: whether
+ * the host asks before a cloud engine's first request (`hostAsks`: it has
+ * `requestCloudConsent`) or sends without asking.
+ */
+declare function aiConsentStepNote(hostAsks: boolean): string;
+/** What a request of each scope sends, as the object of "sends …". */
+declare const AI_SENDS_TEXT: Readonly<Record<AiSendsScope, string>>;
+/** For a request whose feature is unknown. */
+declare const AI_SENDS_FALLBACK = "the text you ask the AI about";
+/**
+ * What a request sends, as the object of a sentence ("MikeDown sends …").
+ * `sends` wins (whole-document Translate runs as the `rewrite` feature);
+ * else the feature's own scope; else a generic phrase.
+ */
+declare function whatIsSent(feature?: string, sends?: AiSendsScope): string;
+/** The policy of the cloud preset on `host` (an engine's base URL host), if one matches. */
+declare function aiProviderPolicyForHost(host: string | null | undefined, presets?: readonly AiEnginePreset[]): AiProviderPolicy | undefined;
+/**
+ * The policy for an engine, matched by its base URL's host (engines do not
+ * store a preset); a host kind with no address (`vscode-lm`) by its kind.
+ */
+declare function aiProviderPolicy(engine: {
+    baseUrl: string;
+    kind?: string;
+}, presets?: readonly AiEnginePreset[]): AiProviderPolicy | undefined;
+/**
+ * Where an engine sends text, as the consent dialog's `host`: the base URL's
+ * host ("api.anthropic.com"), the URL itself when it has none, or the
+ * service's name for a host kind ("GitHub Copilot" for `vscode-lm`).
+ */
+declare function aiConsentHost(engine: {
+    baseUrl: string;
+    kind?: string;
+}): string;
+/** Where a consent answer is remembered: VS Code says workspace, Desktop folder (or session without one). */
+type AiConsentScopeWord = 'workspace' | 'folder' | 'session';
+interface AiConsentTextInput {
+    engineName: string;
+    /** The engine's kind; a host kind (`vscode-lm`) reads as a service built into VS Code, not an address. */
+    kind?: string;
+    /** The engine's host ("api.anthropic.com"), or its base URL when it has none. */
+    host: string;
+    feature?: string;
+    sends?: AiSendsScope;
+    scopeWord: AiConsentScopeWord;
+    /** The provider's policy (see `aiProviderPolicyForHost`). */
+    policy?: AiProviderPolicy | null;
+    /**
+     * Spell the policy link out in the body, for a dialog that can neither
+     * link nor spare a button for it (Desktop's native dialog). VS Code's modal
+     * has a "Read the provider's policy" button instead.
+     */
+    policyLine?: boolean;
+}
+interface AiConsentText {
+    title: string;
+    /** Paragraphs separated by a blank line. */
+    body: string;
+    /** Remembered for the workspace or folder (for the session without one). */
+    allow: string;
+    /** This request only; nothing is remembered and the next request asks again. */
+    allowOnce: string;
+    /** Declines; the host does not ask about this engine again until it restarts. */
+    deny: string;
+    /** The policy button's label, when there is a policy and the body does not spell it out. */
+    readPolicy?: string;
+}
+/** The consent dialog's words, the single source for both hosts. */
+declare function aiConsentText(input: AiConsentTextInput): AiConsentText;
+/** Shown in the Cloud consents list when there is nothing stored. */
+declare const AI_NO_CONSENTS_TEXT = "No cloud engine has been allowed here.";
+/**
+ * One line of the Cloud consents list, without the Forget button:
+ * "Anthropic · this workspace · Allowed". A stored "never" (older versions)
+ * reads "Not allowed"; this session's "Don't allow", "Not allowed until restart".
+ */
+declare function aiConsentSummary(record: Pick<AiConsentRecord, 'answer' | 'scope'>, engineName: string): string;
+
+/**
+ * The setup wizard's first decision, as plain data: which path to offer
+ * first (a running local server, VS Code's Copilot models, or a cloud
+ * provider), whether this machine can run models locally, and how big a
+ * model fits (OQ11, OQ13). No DOM, no network: the host reports the
+ * hardware (`hardwareInfo`), the running servers (`detectLocalServers`) and
+ * its built-in models (`detectHostEngines`).
+ *
+ * Every size here is a hint for a 4-bit quantised model, never a gate: the
+ * user can pick any model.
+ */
+
+/** OQ11: Apple Silicon with this much unified memory can run local models. */
+declare const AI_LOCAL_MIN_UNIFIED_GB = 16;
+/** OQ11: any machine with this much memory can. */
+declare const AI_LOCAL_MIN_MEMORY_GB = 32;
+/** OQ11: or an NVIDIA GPU with this much video memory (Desktop only, where it can be read). */
+declare const AI_LOCAL_MIN_VRAM_GB = 8;
+type AiSetupPath = 'runningLocal' | 'vscodeLm' | 'cloud';
+interface AiSetupInput {
+    /** `detectLocalServers` results (every candidate, running or not). */
+    running: readonly AiLocalServerProbe[];
+    /** `hardwareInfo()`, or null when the host cannot tell. */
+    hardware: AiHardwareInfo | null;
+    /** VS Code only: whether `vscode.lm` offers a Copilot model (see `vscodeLmAvailability`). */
+    vscodeLm?: {
+        available: boolean;
+        models: number;
+    };
+}
+interface AiSetupRecommendation {
+    /** What the wizard offers first. */
+    path: AiSetupPath;
+    /** OQ11: this machine is above the threshold, so local is shown as an option (still under Advanced unless a server runs). */
+    localCapable: boolean;
+    /** The model-size sentence for this machine (OQ11); empty without hardware info. */
+    localHint: string;
+    /**
+     * Step 1's hardware line: "Local is an option on this machine: Apple
+     * Silicon, 32 GB. Models up to about 30B parameters run well." when
+     * capable, the small-machine sentence when not, empty without hardware
+     * info.
+     */
+    hardwareLine: string;
+    /** `runningLocal`: the server to offer (most models first, then preset order). */
+    running?: AiLocalServerProbe;
+    /** Why, one short sentence per signal checked, in order (for tooltips, logs and tests). */
+    reasons: string[];
+}
+/** Bytes to gigabytes, for display ("32 GB"). */
+declare function formatMemoryGb(bytes: number): string;
+/** OQ11's threshold: Apple Silicon with 16 GB or more, any machine with 32 GB or more, or an NVIDIA GPU with 8 GB of VRAM or more. */
+declare function isLocalCapable(hw: AiHardwareInfo | null): boolean;
+/**
+ * The memory a local model runs in: unified memory on Apple Silicon, an
+ * NVIDIA card's VRAM when the host read it, else system memory (CPU
+ * inference: slower, but it runs).
+ */
+declare function modelMemoryBytes(hw: AiHardwareInfo): number;
+/** OQ11's model-size sentence for a machine ("Models up to about 30B parameters run well."); empty for null. */
+declare function localSizeHint(hw: AiHardwareInfo | null): string;
+/** "Apple Silicon, 32 GB", "64 GB of memory, NVIDIA GeForce RTX 4090 (24 GB)", "16 GB of memory". */
+declare function describeHardware(hw: AiHardwareInfo): string;
+/** Shown on a machine below the OQ11 threshold. */
+declare const AI_LOCAL_SMALL_MACHINE = "This machine is on the small side for local models; cloud is the easier path.";
+/** Added when the host read no GPU (VS Code reads none): the hint comes from memory alone. */
+declare const AI_LOCAL_ROUGH_GUESS = "A rough guess from memory alone; the graphics card was not checked.";
+/**
+ * The wizard's path, checked in order (OQ13):
+ *
+ * a. a local server is running and lists models → offer it first;
+ * b. VS Code offers a Copilot model (`vscode-lm`, OQ12) → offer it first;
+ * c. this machine is above the OQ11 threshold → cloud first, with "Local is
+ *    an option on this machine" shown;
+ * d. otherwise cloud, with local under Advanced and no hint.
+ *
+ * `localCapable`, `localHint` and `hardwareLine` are filled whatever the path.
+ */
+declare function recommendSetupPath(input: AiSetupInput): AiSetupRecommendation;
+/** The recommendation's `vscodeLm` input from `detectHostEngines` results. */
+declare function vscodeLmAvailability(probes: readonly AiHostEngineProbe[] | null | undefined): {
+    available: boolean;
+    models: number;
+};
+/**
+ * A model's parameter count in billions, from its id: `7b`, `30b`, `1.5b`,
+ * `270m`, a mixture `8x7b` (total). The first count wins, so `30b-a3b`
+ * (active parameters) reads 30. Null when the id names none.
+ */
+declare function modelParamsBillions(id: string): number | null;
+type AiModelSizeTag = 'fits' | 'tight' | 'too large';
+/**
+ * "fits", "tight" or "too large" for a model on this machine: from the size
+ * the server reported when there is one (`modelSizeHintFromBytes`), else the
+ * parameter count in its id (OQ11's bands, 4-bit). Undefined when neither is
+ * known or the hardware is unknown: no tag. A hint only; nothing is blocked.
+ */
+declare function modelSizeHint(id: string, hardware: AiHardwareInfo | null, sizeBytes?: number): AiModelSizeTag | undefined;
+/**
+ * "fits", "tight" or "too large" from a size the server reported (bytes on
+ * disk or its load estimate), against this machine's model memory.
+ */
+declare function modelSizeHintFromBytes(sizeBytes: number, hardware: AiHardwareInfo): AiModelSizeTag;
+/** A model size for a picker row: "16 GB", "2.6 GB", "0.2 GB". */
+declare function formatModelSize(bytes: number): string;
+/**
+ * The active parameters (billions) an id names, as mixture-of-experts models
+ * do: `Qwen3.6-35B-A3B`, `qwen3.5-122b-a10b`, `Nemotron-3-Super-120B-A12B`.
+ * Null when the id names none.
+ */
+declare function modelActiveParamsBillions(id: string): number | null;
+/**
+ * Whether a model is a mixture of experts, from its id's active parameters or
+ * the server's word for it (`moe`: LM Studio's `arch`, oMLX's
+ * `config_model_type`). Only a few billion parameters run per token, so it is
+ * much faster than its size suggests. A row hint only, never a reason to pick it.
+ */
+declare function modelMoeHint(id: string, moe?: boolean): {
+    activeBillions: number | null;
+} | null;
+/**
+ * The picker's "MoE · fast" hint: a mixture of experts that also fits this
+ * machine (`fits`). A tight fit (a 409 GB model on a 512 GB Mac) or one too
+ * large runs slowly however few parameters work per token, and an unknown fit
+ * proves nothing, so neither gets the speed hint (Q5).
+ */
+declare function modelMoeFastHint(id: string, moe: boolean | undefined, size: AiModelSizeTag | undefined): {
+    activeBillions: number | null;
+} | null;
+/** One model as `localDefaultModel` weighs it. */
+interface AiLocalModelChoice {
+    id: string;
+    /** Can chat (an `llm` or `vlm`; not embeddings, speech or a converter). */
+    chat: boolean;
+    missing?: boolean;
+    /** Loaded on the server right now. */
+    loaded?: boolean;
+}
+/**
+ * The model a new local engine starts with: a chat model the server has
+ * loaded, else null and the user picks. Size is a poor guide to speed (a
+ * mixture of experts runs far faster than a dense model its size), so no
+ * guess is made from it.
+ */
+declare function localDefaultModel(models: readonly AiLocalModelChoice[]): string | null;
+
+export { AI_AUDIENCES, AI_CHARS_PER_TOKEN, AI_CLOUD_PRIVACY, AI_ENGINE_PRESETS, AI_ERROR_COPY, AI_FEATURES, AI_HOST_PRESET_FAMILY, AI_HOST_PRIVACY, AI_LOCAL_DETECT_TIMEOUT_MS, AI_LOCAL_MIN_MEMORY_GB, AI_LOCAL_MIN_UNIFIED_GB, AI_LOCAL_MIN_VRAM_GB, AI_LOCAL_ROUGH_GUESS, AI_LOCAL_SMALL_MACHINE, AI_NO_CONSENTS_TEXT, AI_PRESET_FAMILIES, AI_REWRITE_VARIANTS, AI_SENDS_FALLBACK, AI_SENDS_TEXT, AI_TASKS, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODEL_TABLE, AiApiKeyFile, AiCapabilityFlag, AiCompletionRequest, AiCompletionResult, AiConsentRecord, AiDiscoveredModel, AiEngineConfig, AiEngineKind, AiEngineStatus, AiError, AiErrorCode, AiFeatureSettings, AiFinishReason, AiHardwareInfo, AiHostEngineProbe, AiLocalServerProbe, AiLocality, AiMessage, AiModelCapabilities, AiModelConfig, AiSendsScope, AiSettings, AiUsage, CHARS_PER_TOKEN, DEFAULT_LOCAL_NETWORKS, EXPLAIN_MAX_TOKENS, EXPLAIN_SYSTEM_ADDENDUM, EXPLAIN_SYSTEM_PROMPT, JSON_ONLY_INSTRUCTION, JSON_SHAPE_HINT, MODEL_LOAD_FAILED_PHRASES, OPENAI_MODEL_TABLE, OUTLINE_SYSTEM_PROMPT, PROPERTIES_SYSTEM_PROMPT, PROPERTY_DESCRIPTION_MAX_CHARS, PROPERTY_MAX_TAGS, PROPERTY_TITLE_MAX_CHARS, PROPERTY_VOCABULARY_MAX, RETRYABLE_REQUEST_PARAMS, REWRITE_CONTEXT_CHARS, REWRITE_INSTRUCTION_MAX_CHARS, REWRITE_LANGUAGE_MAX_CHARS, REWRITE_SYSTEM_PROMPT, STREAM_USAGE_HOSTS, SUMMARIZE_MIN_CONTEXT_TOKENS, SUMMARY_SHORT_DOCUMENT_CHARS, SUMMARY_SYSTEM_PROMPT, SseParser, THINKING_DEFAULT_HEADROOM_TOKENS, THINKING_HEADROOM_TOKENS, THINKING_MAX_TOKENS_CAP, TITLE_MAX_CHARS, TITLE_OUTLINE_MAX_ITEMS, TITLE_SYSTEM_PROMPT, TRANSLATE_DOCUMENT_NOTE, TRANSLATE_SYSTEM_ADDENDUM, aiConsentHost, aiConsentStepNote, aiConsentSummary, aiConsentText, aiErrorCodeFromHttp, aiErrorCopy, aiLengthLimitCopy, aiProviderPolicy, aiProviderPolicyForHost, aiResultStats, aiResultStatsText, aiResultStatsTitle, aiTimingLogParts, anthropicNextPage, base64ToBytes, budgetDocument, buildAuthHeaders, buildCompletionBody, buildEmbeddingsBody, buildExplainMessages, buildPropertiesMessages, buildRewriteMessages, buildSummaryMessages, buildTitleMessages, bytesToBase64, checkMarkdownStructure, combineRequirements, completeCapabilities, countDetectedModels, countMarkdownStructure, coveragePercent, createAnthropicStreamReader, createCompletionStreamReader, createOpenAiStreamReader, defaultAiSettings, describeHardware, detectCapabilities, detectLocality, engineEndpoints, engineLocality, escapeClosingTag, existingTagsOf, explainMaxTokens, finalizeRewriteText, finalizeSummary, formatAiSeconds, formatAiTokensPerSecond, formatMemoryGb, formatModelSize, fromWireCompletionRequest, getAiAudience, getAiFeature, getAiRewriteVariant, getAiTask, headingsOutline, hostOfUrl, isAiError, isAiErrorCode, isLocalCapable, isOpenAiReasoningModel, isRouteUsable, jsonRepairMessages, localDefaultModel, localDetectCandidates, localDetectTarget, localDetectUrl, localSizeHint, localityMismatch, makeAiError, mergeDiscoveredModels, mergeRequestOverrides, missingCapabilities, modelActiveParamsBillions, modelMemoryBytes, modelMoeFastHint, modelMoeHint, modelParamsBillions, modelSizeHint, modelSizeHintFromBytes, nearestThinkingLevel, normalizeRewriteLanguage, openAiOffReasoningEffort, parseAnthropicModels, parseEmbeddingsResponse, parseLenientJson, parseLmStudioModels, parseModelSizes, parseOllamaRunning, parseOllamaShow, parseOllamaTags, parseOmlxModelStatus, parseOpenAiModelList, parsePropertySuggestions, parseTitles, presetForEngine, propertiesMaxTokens, recommendSetupPath, renderHeadingOutline, resolveAiFeature, resolveRoute, resolveThinkingLevel, rewriteInstruction, rewriteMaxTokens, rewriteSystemPrompt, rewriteVisibleText, streamUsageSupported, summaryMaxTokens, summaryPreviewText, summaryVisibleText, taskThinkingDefault, thinkingChoices, thinkingLevelFrom, thinkingMaxTokens, thinkingOverrides, titleMaxTokens, toAiError, toWireCompletionRequest, trimRewriteContext, unsupportedRequestParam, vscodeLmAvailability, whatIsSent, withModelSizes, withModelStatus, withStreamUsage, withThinkingLevel, withoutRequestParam };
+export type { AiAudience, AiAudienceDefinition, AiCapabilityRequirements, AiConsentScopeWord, AiConsentState, AiConsentText, AiConsentTextInput, AiEngineEndpoints, AiEnginePreset, AiErrorCopy, AiFeatureDefinition, AiFrontmatterEntry, AiLocalDetectTarget, AiLocalModelChoice, AiModelSizeTag, AiPopularRule, AiPresetFamily, AiPresetFamilyInfo, AiProviderPolicy, AiResultStats, AiRewriteGroup, AiRewriteOutput, AiRewriteParams, AiRewriteScope, AiRewriteVariant, AiRewriteVariantDefinition, AiRouteOk, AiRouteResolution, AiRouteUnusable, AiSetupInput, AiSetupPath, AiSetupRecommendation, AiSummaryKind, AiTaskDefinition, AiThinkingChoice, AiThinkingJob, AiThinkingLevel, AiThinkingOptions, AiUnusableCode, AiWireCompletionRequest, AiWireMessage, AiWireMessagePart, BudgetedDocument, BuildCompletionOptions, CompletionStreamReader, DetectedCapabilities, DocumentBudgetOptions, ExplainPromptInput, HeadingOutlineEntry, LenientJsonResult, ParsedPropertySuggestions, ParsedTitles, PropertiesPromptInput, PropertySuggestions, ResolveRouteOptions, ResolvedAiFeature, ResolvedThinkingLevel, RewritePromptInput, SseEvent, StreamOutcome, StructureCounts, StructureDiff, StructureMismatch, SuggestedTag, SummaryPromptInput, ThinkingBudgetOptions, TitlePromptInput };