@mikedown/core 0.1.0 → 0.3.0

package/dist/chunk-JZWKEBCI.js

@@ -0,0 +1,3899 @@
+import {
+  defaultAiSettings,
+  detectLocality,
+  engineLocality,
+  hostOfUrl,
+  normalizeTag
+} from "./chunk-QDVY7WW6.js";
+
+// src/ai/types.ts
+var AI_ENGINE_KINDS = ["openai-compatible", "lmstudio", "ollama", "anthropic", "openai", "vscode-lm"];
+var AI_HOST_ENGINE_KINDS = ["vscode-lm"];
+var AI_CAPABILITY_FLAGS = ["chat", "stream", "vision", "json", "tools", "fim", "embed"];
+var DEFAULT_CONTEXT_TOKENS = 8192;
+var AI_FALLBACK_MODES = ["none", "default", "anyLocal", "any"];
+var AI_ERROR_CODES = [
+  "unreachable",
+  "auth",
+  "modelNotFound",
+  "modelLoadFailed",
+  "contextOverflow",
+  "rateLimited",
+  "cloudBlocked",
+  "consentDenied",
+  "cancelled",
+  "badOutput",
+  "unknown"
+];
+
+// src/ai/tasks.ts
+var SUMMARIZE_MIN_CONTEXT_TOKENS = 32768;
+var AI_TASKS = [
+  {
+    id: "rewrite",
+    label: "Rewrite",
+    description: "Selection rewrite, explain or expand, reading level, translation.",
+    requires: { chat: true, stream: true }
+  },
+  {
+    id: "continue",
+    label: "Continue",
+    description: "Inline ghost text. Prefers a small fill-in-the-middle model.",
+    requires: { stream: true },
+    requiresAny: ["fim", "chat"]
+  },
+  {
+    id: "chat",
+    label: "Chat",
+    description: "Chat with the document, prompt blocks.",
+    requires: { chat: true, stream: true }
+  },
+  {
+    id: "summarize",
+    label: "Summarize",
+    description: 'Summaries and "what changed". Works best with a large context window; long documents are cut and labelled.',
+    requires: { chat: true },
+    prefers: { contextTokens: SUMMARIZE_MIN_CONTEXT_TOKENS }
+  },
+  {
+    id: "structure",
+    label: "Structure",
+    description: "Frontmatter and tags, Mermaid, tables, code, titles, paste cleanup. Prefers a model with JSON output.",
+    requires: { chat: true },
+    prefers: { json: true }
+  },
+  {
+    id: "notes",
+    label: "Notes",
+    description: "Meeting notes to action items.",
+    requires: { chat: true, json: true }
+  },
+  {
+    id: "review",
+    label: "Review",
+    description: "Grammar pass and consistency checks.",
+    requires: { chat: true, json: true }
+  },
+  {
+    id: "vision",
+    label: "Vision",
+    description: "Alt text for images.",
+    requires: { vision: true }
+  },
+  {
+    id: "embed",
+    label: "Embeddings",
+    description: "Workspace search and link suggestions.",
+    requires: { embed: true },
+    hostMethod: "embed"
+  },
+  {
+    id: "transcribe",
+    label: "Transcribe",
+    description: "Dictation, through the host.",
+    requires: {},
+    hostMethod: "transcribe"
+  }
+];
+function getAiTask(id) {
+  return AI_TASKS.find((t) => t.id === id);
+}
+function combineRequirements(a, b) {
+  const out = { ...a };
+  for (const [key, value] of Object.entries(b)) {
+    if (key === "contextTokens") {
+      if (typeof value === "number") {
+        out.contextTokens = Math.max(out.contextTokens ?? 0, value);
+      }
+    } else if (value === true) {
+      out[key] = true;
+    }
+  }
+  return out;
+}
+function missingCapabilities(caps, requires, requiresAny, defaultContextTokens = DEFAULT_CONTEXT_TOKENS) {
+  const missing = [];
+  for (const [key, value] of Object.entries(requires)) {
+    if (key === "contextTokens") {
+      if (typeof value === "number" && (caps.contextTokens ?? defaultContextTokens) < value) {
+        missing.push("contextTokens");
+      }
+    } else if (value === true && !caps[key]) {
+      missing.push(key);
+    }
+  }
+  if (requiresAny && requiresAny.length > 0 && !requiresAny.some((flag) => caps[flag])) {
+    missing.push(requiresAny[0]);
+  }
+  return missing;
+}
+
+// src/ai/features.ts
+var AI_FEATURES = [
+  {
+    id: "rewrite",
+    label: "Rewrite selection",
+    description: "Shorter, longer, fix flow or a custom prompt, previewed before it replaces the selection.",
+    defaultEnabled: true,
+    defaultTask: "rewrite",
+    requires: { chat: true, stream: true },
+    status: "available",
+    sends: "selection"
+  },
+  {
+    id: "ghostText",
+    label: "Inline suggestions",
+    description: "Dim continuation text while you write. Sends the text around the cursor as you type.",
+    // Separate opt-in even with the master switch on (brainstorm idea 1).
+    defaultEnabled: false,
+    defaultTask: "continue",
+    requires: { stream: true },
+    status: "planned"
+  },
+  {
+    id: "chat",
+    label: "Chat with this document",
+    description: "A sidebar chat with the document as context.",
+    defaultEnabled: true,
+    defaultTask: "chat",
+    requires: { chat: true, stream: true },
+    status: "planned",
+    sends: "document"
+  },
+  {
+    id: "summary",
+    label: "Summary",
+    description: "Insert a summary or outline of the document.",
+    defaultEnabled: true,
+    defaultTask: "summarize",
+    requires: { chat: true },
+    status: "available",
+    sends: "document"
+  },
+  {
+    id: "frontmatter",
+    label: "Frontmatter and tags",
+    description: "Suggest a title, tags and other properties.",
+    defaultEnabled: true,
+    defaultTask: "structure",
+    requires: { chat: true },
+    status: "available",
+    sends: "documentAndTags"
+  },
+  {
+    id: "title",
+    label: "Suggest titles",
+    description: "Offer a few titles for the document.",
+    defaultEnabled: true,
+    defaultTask: "structure",
+    requires: { chat: true },
+    status: "available",
+    sends: "document"
+  },
+  {
+    id: "altText",
+    label: "Image alt text",
+    description: "Describe pasted images for their alt text.",
+    defaultEnabled: true,
+    defaultTask: "vision",
+    requires: { vision: true },
+    status: "planned"
+  }
+];
+function getAiFeature(id) {
+  return AI_FEATURES.find((f) => f.id === id);
+}
+function resolveAiFeature(features, id) {
+  const definition = getAiFeature(id);
+  const saved = features[id] ?? {};
+  return {
+    id,
+    enabled: saved.enabled ?? definition?.defaultEnabled ?? false,
+    task: saved.task ?? definition?.defaultTask ?? id,
+    requires: definition?.requires ?? {},
+    definition
+  };
+}
+
+// src/ai/capabilityHeuristics.ts
+var BASE_CAPABILITIES = {
+  chat: true,
+  stream: true,
+  vision: false,
+  json: false,
+  tools: false,
+  fim: false,
+  embed: false,
+  contextTokens: null
+};
+var NOT_A_CHAT_MODEL = { chat: false, stream: false, vision: false, json: false, tools: false, fim: false };
+var FAMILY_RULES = [
+  { family: "qwen", pattern: /qwen/, caps: { json: true, tools: true, contextTokens: 32768 } },
+  { family: "qwen3", pattern: /qwen-?3(?![.\d])/, caps: { contextTokens: 40960 } },
+  // Qwen 3.5 and later (and the qwen4_exp preview) carry vision in the same weights.
+  { family: "qwen3.5+", pattern: /qwen-?3\.[5-9]|qwen-?4/, caps: { vision: true, contextTokens: 262144 } },
+  { family: "qwen-coder", pattern: /qwen.*coder/, caps: { vision: false, fim: true, contextTokens: 262144 } },
+  { family: "qwen2.5-coder", pattern: /qwen-?2\.5.*coder/, caps: { contextTokens: 32768 } },
+  { family: "gemma", pattern: /gemma/, caps: { json: true, contextTokens: 8192 } },
+  { family: "gemma3", pattern: /gemma-?3/, caps: { vision: true, contextTokens: 131072 } },
+  { family: "gemma4", pattern: /gemma-?4/, caps: { vision: true, tools: true, contextTokens: 131072 } },
+  { family: "codegemma", pattern: /codegemma/, caps: { vision: false, fim: true } },
+  { family: "llama3.1+", pattern: /llama-?3\.[1-3]/, caps: { json: true, tools: true, contextTokens: 131072 } },
+  { family: "llama4", pattern: /llama-?4/, caps: { json: true, tools: true, vision: true, contextTokens: 131072 } },
+  { family: "mistral", pattern: /mistral|mixtral|ministral|magistral/, caps: { json: true, tools: true, contextTokens: 32768 } },
+  { family: "mistral-vision", pattern: /mistral-small-3\.[1-9]|mistral-medium|magistral|pixtral/, caps: { vision: true, contextTokens: 131072 } },
+  { family: "codestral", pattern: /codestral/, caps: { fim: true, json: true, contextTokens: 32768 } },
+  { family: "deepseek", pattern: /deepseek/, caps: { json: true, tools: true, contextTokens: 131072 } },
+  { family: "deepseek-v4", pattern: /deepseek-?v4/, caps: { contextTokens: 1048576 } },
+  { family: "deepseek-coder", pattern: /deepseek-coder/, caps: { fim: true } },
+  { family: "minimax", pattern: /minimax/, caps: { json: true, tools: true, contextTokens: 196608 } },
+  { family: "glm", pattern: /glm/, caps: { json: true, tools: true, contextTokens: 131072 } },
+  { family: "glm5", pattern: /glm-?5/, caps: { contextTokens: 1048576 } },
+  { family: "gpt-oss", pattern: /gpt-oss/, caps: { json: true, tools: true, contextTokens: 131072 } },
+  { family: "phi4", pattern: /phi-?4/, caps: { json: true, contextTokens: 16384 } },
+  { family: "hermes", pattern: /hermes/, caps: { json: true, tools: true } },
+  { family: "nemotron", pattern: /nemotron/, caps: { json: true, tools: true, contextTokens: 131072 } },
+  { family: "starcoder", pattern: /starcoder|stable-?code/, caps: { fim: true } },
+  // Name markers for multimodal builds, whatever the family.
+  { family: "vision", pattern: /(^|[^a-z])vl([^a-z]|$)|vision|llava|minicpm-v|moondream|omni|multimodal/, caps: { vision: true } },
+  // Embedding models: not chat models at all.
+  { family: "embedding", pattern: /embed|(^|[/_-])(bge|gte|e5)-|minilm|mxbai|arctic-embed|snowflake/, caps: { ...NOT_A_CHAT_MODEL, embed: true, contextTokens: 8192 } },
+  { family: "bge", pattern: /(^|[/_-])bge-(small|base|large)/, caps: { contextTokens: 512 } },
+  // Speech and rerankers.
+  { family: "speech", pattern: /whisper|parakeet|kokoro|(^|[/_-])tts([/_-]|$)|rerank/, caps: { ...NOT_A_CHAT_MODEL, embed: false } }
+];
+var CLAUDE_BASE = { chat: true, stream: true, vision: true, json: true, tools: true, fim: false, embed: false };
+var ANTHROPIC_MODEL_TABLE = [
+  { prefix: "claude-", caps: { ...CLAUDE_BASE, contextTokens: 2e5 } },
+  { prefix: "claude-3", caps: { contextTokens: 2e5 } },
+  { prefix: "claude-haiku-4-5", caps: { contextTokens: 2e5 } },
+  { prefix: "claude-opus-4-6", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-opus-4-7", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-opus-4-8", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-sonnet-4-6", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-opus-5", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-sonnet-5", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-haiku-5", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-fable-5", caps: { contextTokens: 1e6 } },
+  { prefix: "claude-mythos-5", caps: { contextTokens: 1e6 } }
+];
+var OPENAI_MODEL_TABLE = [
+  { prefix: "gpt-", caps: { chat: true, stream: true, json: true, tools: true, vision: false, fim: false, embed: false, contextTokens: 128e3 } },
+  { prefix: "gpt-3.5", caps: { contextTokens: 16385 } },
+  { prefix: "gpt-4o", caps: { vision: true, contextTokens: 128e3 } },
+  { prefix: "gpt-4.1", caps: { vision: true, contextTokens: 1047576 } },
+  { prefix: "gpt-5", caps: { vision: true, contextTokens: 4e5 } },
+  { prefix: "gpt-oss", caps: { contextTokens: 131072 } },
+  { prefix: "o1", caps: { chat: true, stream: true, json: true, tools: true, vision: true, contextTokens: 2e5 } },
+  { prefix: "o3", caps: { chat: true, stream: true, json: true, tools: true, vision: true, contextTokens: 2e5 } },
+  { prefix: "o4", caps: { chat: true, stream: true, json: true, tools: true, vision: true, contextTokens: 2e5 } },
+  { prefix: "text-embedding-", caps: { ...NOT_A_CHAT_MODEL, embed: true, contextTokens: 8191 } },
+  { prefix: "whisper", caps: NOT_A_CHAT_MODEL },
+  { prefix: "tts-", caps: NOT_A_CHAT_MODEL },
+  { prefix: "gpt-4o-mini-tts", caps: NOT_A_CHAT_MODEL },
+  { prefix: "gpt-4o-transcribe", caps: NOT_A_CHAT_MODEL },
+  { prefix: "gpt-image", caps: NOT_A_CHAT_MODEL },
+  { prefix: "dall-e", caps: NOT_A_CHAT_MODEL },
+  { prefix: "omni-moderation", caps: NOT_A_CHAT_MODEL }
+];
+var OPENAI_REASONING_ID = /^(o\d+|gpt-([5-9]|\d{2,})(\.\d+)?)(-|$)/;
+function isOpenAiReasoningModel(modelId, kind) {
+  const id = bareOpenAiId(modelId, kind);
+  return id !== null && OPENAI_REASONING_ID.test(id);
+}
+function bareOpenAiId(modelId, kind) {
+  const id = modelId.trim().toLowerCase();
+  if (kind === "openai") {
+    return id.slice(id.lastIndexOf("/") + 1);
+  }
+  return id.startsWith("openai/") ? id.slice("openai/".length) : null;
+}
+var OPENAI_NONE_EFFORT_ID = /^gpt-5\.[1-9]\d*(-|$)/;
+var OPENAI_MINIMAL_EFFORT_ID = /^gpt-5(-|$)/;
+function openAiOffReasoningEffort(modelId, kind) {
+  const id = bareOpenAiId(modelId, kind);
+  if (id === null || !OPENAI_REASONING_ID.test(id)) {
+    return null;
+  }
+  if (/codex|-pro(-|$)/.test(id)) {
+    return "low";
+  }
+  if (OPENAI_NONE_EFFORT_ID.test(id)) {
+    return "none";
+  }
+  if (OPENAI_MINIMAL_EFFORT_ID.test(id)) {
+    return "minimal";
+  }
+  return "low";
+}
+function matchCloudTable(table, id) {
+  const rows = table.filter((r) => id.startsWith(r.prefix)).sort((a, b) => a.prefix.length - b.prefix.length);
+  if (rows.length === 0) {
+    return null;
+  }
+  return { caps: Object.assign({}, ...rows.map((r) => r.caps)), prefix: rows[rows.length - 1].prefix };
+}
+function detectCapabilities(modelId, kind) {
+  if (kind === "vscode-lm") {
+    return { capabilities: withDefaultContext({ ...BASE_CAPABILITIES }), family: "vscode-lm" };
+  }
+  const id = modelId.trim().toLowerCase();
+  const bare = id.slice(id.lastIndexOf("/") + 1);
+  const cloudTable = kind === "anthropic" || bare.startsWith("claude-") ? ANTHROPIC_MODEL_TABLE : kind === "openai" || /^(gpt-[\d.]|o[134](-|$)|text-embedding-|whisper|tts-|dall-e|gpt-image|omni-moderation)/.test(bare) ? OPENAI_MODEL_TABLE : null;
+  if (cloudTable) {
+    const hit = matchCloudTable(cloudTable, bare);
+    if (hit) {
+      return { capabilities: withDefaultContext({ ...BASE_CAPABILITIES, ...hit.caps }), family: hit.prefix };
+    }
+  }
+  let caps = { ...BASE_CAPABILITIES };
+  let family = null;
+  for (const rule of FAMILY_RULES) {
+    if (rule.pattern.test(id)) {
+      caps = { ...caps, ...rule.caps };
+      family = rule.family;
+    }
+  }
+  return { capabilities: withDefaultContext(caps), family };
+}
+function withDefaultContext(caps) {
+  return caps.contextTokens === null ? { ...caps, contextTokens: DEFAULT_CONTEXT_TOKENS } : caps;
+}
+function completeCapabilities(partial, modelId, kind) {
+  const out = { ...detectCapabilities(modelId, kind).capabilities };
+  for (const [key, value] of Object.entries(partial)) {
+    if (key === "contextTokens") {
+      if (typeof value === "number" && value > 0) {
+        out.contextTokens = value;
+      }
+    } else if (typeof value === "boolean" && key in out) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function mergeDiscoveredModels(existing, discovered, kind, opts = {}) {
+  const addEnabled = opts.addEnabled ?? true;
+  const found = /* @__PURE__ */ new Map();
+  for (const d of discovered) {
+    if (!found.has(d.id)) {
+      found.set(d.id, d);
+    }
+  }
+  const merged = existing.map((model) => {
+    const d = found.get(model.id);
+    if (!d) {
+      return model.manual ? model : { ...model, missing: true };
+    }
+    const next = { ...model, label: model.label ?? d.label };
+    delete next.missing;
+    if (next.label === void 0) {
+      delete next.label;
+    }
+    if (model.capabilitiesSource !== "user") {
+      next.capabilities = completeCapabilities(d.capabilities, d.id, kind);
+      next.capabilitiesSource = d.source;
+    }
+    return next;
+  });
+  const known = new Set(existing.map((m) => m.id));
+  for (const d of found.values()) {
+    if (known.has(d.id)) {
+      continue;
+    }
+    const added = {
+      id: d.id,
+      enabled: addEnabled,
+      capabilities: completeCapabilities(d.capabilities, d.id, kind),
+      capabilitiesSource: d.source
+    };
+    if (d.label !== void 0) {
+      added.label = d.label;
+    }
+    merged.push(added);
+  }
+  return merged;
+}
+
+// src/ai/presets.ts
+var AI_PRESET_FAMILIES = [
+  {
+    family: "local",
+    label: "Run on this machine",
+    explainer: "Your own model server, on this computer or your network. Text never leaves it."
+  },
+  {
+    family: "cloud",
+    label: "Cloud API key",
+    explainer: "Paste a key from the provider. It bills your account for what you use."
+  }
+];
+var AI_HOST_PRESET_FAMILY = {
+  family: "host",
+  label: "Built into VS Code",
+  explainer: "A model VS Code already offers through your GitHub Copilot plan. No key to paste; text goes to GitHub\u2019s Copilot service."
+};
+var anthropicFamily = (word, label) => ({ label, match: new RegExp(`^claude-${word}-\\d`) });
+var AI_ENGINE_PRESETS = [
+  {
+    id: "omlx",
+    name: "oMLX",
+    kind: "openai-compatible",
+    baseUrl: "http://127.0.0.1:8000/v1",
+    apiKeyEnv: "OMLX_API_KEY",
+    apiKeyFile: { path: "~/.omlx/settings.json", jsonPath: "auth.api_key" },
+    needsKey: true,
+    family: "local",
+    caption: "MLX models on Apple silicon",
+    keyHint: "oMLX keeps its key in ~/.omlx/settings.json, which is read automatically.",
+    installUrl: "https://omlx.ai"
+  },
+  {
+    id: "lmstudio",
+    name: "LM Studio",
+    kind: "lmstudio",
+    baseUrl: "http://127.0.0.1:1234/v1",
+    needsKey: false,
+    family: "local",
+    caption: "The LM Studio app\u2019s local server",
+    keyHint: "Only needed if you turned on authentication in LM Studio.",
+    installUrl: "https://lmstudio.ai/download",
+    detectPath: "/api/v0/models"
+  },
+  {
+    id: "ollama",
+    name: "Ollama",
+    kind: "ollama",
+    baseUrl: "http://127.0.0.1:11434/v1",
+    needsKey: false,
+    family: "local",
+    caption: "Models pulled with ollama",
+    keyHint: "Ollama needs no key.",
+    installUrl: "https://ollama.com/download",
+    detectPath: "/api/tags"
+  },
+  {
+    id: "llamacpp",
+    name: "llama.cpp server",
+    kind: "openai-compatible",
+    baseUrl: "http://127.0.0.1:8080/v1",
+    needsKey: false,
+    family: "local",
+    caption: "llama-server with a GGUF model",
+    keyHint: "Only needed if you started llama-server with --api-key.",
+    installUrl: "https://github.com/ggml-org/llama.cpp/blob/master/docs/install.md"
+  },
+  {
+    id: "vllm",
+    name: "vLLM",
+    kind: "openai-compatible",
+    baseUrl: "http://127.0.0.1:8000/v1",
+    apiKeyEnv: "VLLM_API_KEY",
+    needsKey: false,
+    family: "local",
+    caption: "vllm serve on a GPU box",
+    keyHint: "Only needed if you started vLLM with --api-key.",
+    installUrl: "https://docs.vllm.ai/en/latest/getting_started/installation/"
+  },
+  {
+    id: "custom",
+    name: "Custom OpenAI-compatible",
+    kind: "openai-compatible",
+    baseUrl: "http://127.0.0.1:8000/v1",
+    needsKey: false,
+    family: "local",
+    caption: "Any server that speaks the OpenAI API",
+    keyHint: "Leave blank if the server has no auth."
+  },
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    kind: "anthropic",
+    baseUrl: "https://api.anthropic.com",
+    apiKeyEnv: "ANTHROPIC_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "Claude models, API key from Anthropic",
+    keyHint: "Get an API key in the Claude Console",
+    keyUrl: "https://platform.claude.com/settings/keys",
+    pricingUrl: "https://platform.claude.com/docs/en/about-claude/pricing",
+    policy: { label: "Anthropic privacy and data use", url: "https://privacy.claude.com/en/collections/10663361-commercial-customers" },
+    popular: [anthropicFamily("sonnet", "Sonnet"), anthropicFamily("opus", "Opus"), anthropicFamily("haiku", "Haiku")]
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    kind: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    apiKeyEnv: "OPENAI_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "GPT models, API key from OpenAI",
+    keyHint: "Get an API key on the OpenAI platform",
+    keyUrl: "https://platform.openai.com/api-keys",
+    pricingUrl: "https://developers.openai.com/api/docs/pricing",
+    policy: { label: "OpenAI API data controls", url: "https://developers.openai.com/api/docs/guides/your-data" },
+    popular: [
+      { label: "Flagship", match: /^gpt-\d+(\.\d+)?$/ },
+      { label: "Mini", match: /^gpt-\d+(\.\d+)?-mini$/ }
+    ]
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    kind: "openai-compatible",
+    baseUrl: "https://openrouter.ai/api/v1",
+    apiKeyEnv: "OPENROUTER_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "Models from many providers with one key",
+    keyHint: "Get an API key on OpenRouter",
+    keyUrl: "https://openrouter.ai/keys",
+    pricingUrl: "https://openrouter.ai/pricing",
+    policy: {
+      label: "OpenRouter privacy policy",
+      url: "https://openrouter.ai/privacy",
+      note: "OpenRouter passes each request on to the provider that serves the model, whose own terms apply as well."
+    },
+    popular: [
+      { label: "Claude Sonnet", match: /^anthropic\/claude-sonnet-\d/ },
+      { label: "GPT", match: /^openai\/gpt-\d+(\.\d+)?$/ },
+      { label: "Gemini Pro", match: /^google\/gemini-\d+(\.\d+)?-pro$/ },
+      { label: "Gemini Flash", match: /^google\/gemini-\d+(\.\d+)?-flash$/ }
+    ]
+  },
+  {
+    id: "gemini",
+    name: "Google Gemini",
+    kind: "openai-compatible",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    apiKeyEnv: "GEMINI_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "Gemini models, API key from Google AI Studio",
+    keyHint: "Get an API key in Google AI Studio",
+    keyUrl: "https://aistudio.google.com/apikey",
+    pricingUrl: "https://ai.google.dev/gemini-api/docs/pricing",
+    policy: { label: "Gemini API terms and data use", url: "https://ai.google.dev/gemini-api/terms" },
+    popular: [
+      { label: "Flash", match: /(^|\/)gemini-\d+(\.\d+)?-flash$/ },
+      { label: "Pro", match: /(^|\/)gemini-\d+(\.\d+)?-pro$/ },
+      { label: "Flash-Lite", match: /(^|\/)gemini-\d+(\.\d+)?-flash-lite$/ }
+    ]
+  },
+  {
+    id: "groq",
+    name: "Groq",
+    kind: "openai-compatible",
+    baseUrl: "https://api.groq.com/openai/v1",
+    apiKeyEnv: "GROQ_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "Fast open models such as Llama and Qwen",
+    keyHint: "Get an API key in the Groq console",
+    keyUrl: "https://console.groq.com/keys",
+    pricingUrl: "https://console.groq.com/docs/models",
+    policy: { label: "Groq: your data in GroqCloud", url: "https://console.groq.com/docs/your-data" },
+    popular: [
+      { label: "GPT-OSS", match: /^openai\/gpt-oss-\d+b$/ },
+      { label: "Llama", match: /^(meta-llama\/)?llama-\d/, exclude: /guard|prompt/ },
+      { label: "Qwen", match: /^qwen\/qwen\d/ }
+    ]
+  },
+  {
+    id: "mistral",
+    name: "Mistral",
+    kind: "openai-compatible",
+    baseUrl: "https://api.mistral.ai/v1",
+    apiKeyEnv: "MISTRAL_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "Mistral models, API key from Mistral",
+    keyHint: "Get an API key in the Mistral console",
+    keyUrl: "https://console.mistral.ai/api-keys",
+    pricingUrl: "https://mistral.ai/pricing",
+    policy: { label: "Mistral AI privacy policy", url: "https://legal.mistral.ai/terms/privacy-policy/" },
+    popular: [
+      { label: "Medium", match: /^mistral-medium-/, prefer: /-latest$/ },
+      { label: "Large", match: /^mistral-large-/, prefer: /-latest$/ },
+      { label: "Small", match: /^mistral-small-/, prefer: /-latest$/ }
+    ]
+  },
+  {
+    id: "deepseek",
+    name: "DeepSeek",
+    kind: "openai-compatible",
+    baseUrl: "https://api.deepseek.com/v1",
+    apiKeyEnv: "DEEPSEEK_API_KEY",
+    needsKey: true,
+    family: "cloud",
+    caption: "DeepSeek chat and reasoning models",
+    keyHint: "Get an API key on the DeepSeek platform",
+    keyUrl: "https://platform.deepseek.com/api_keys",
+    pricingUrl: "https://api-docs.deepseek.com/quick_start/pricing",
+    policy: { label: "DeepSeek privacy policy", url: "https://cdn.deepseek.com/policies/en-US/deepseek-privacy-policy.html" },
+    popular: [
+      { label: "Chat", match: /^deepseek-chat/ },
+      { label: "Reasoner", match: /^deepseek-reasoner/ }
+    ]
+  },
+  {
+    id: "vscodelm",
+    name: "GitHub Copilot",
+    kind: "vscode-lm",
+    baseUrl: "",
+    needsKey: false,
+    family: "host",
+    caption: "Copilot\u2019s models in VS Code, no key needed",
+    keyHint: "No key: VS Code signs in to GitHub Copilot for you. Needs a Copilot plan and the GitHub Copilot Chat extension.",
+    pricingUrl: "https://github.com/features/copilot/plans",
+    policy: {
+      label: "GitHub Copilot Trust Center",
+      url: "https://copilot.github.trust.page/",
+      note: "Text goes to GitHub\u2019s Copilot service under your Copilot plan; individual and business plans handle data differently."
+    }
+  }
+];
+function urlKey(url) {
+  return url.trim().toLowerCase().replace(/\/+$/, "");
+}
+function presetForEngine(engine, presets = AI_ENGINE_PRESETS) {
+  const sameKind = presets.filter((p) => p.kind === engine.kind);
+  const exact = sameKind.filter((p) => urlKey(p.baseUrl) === urlKey(engine.baseUrl));
+  if (exact.length > 0) {
+    return exact.find((p) => p.apiKeyEnv && p.apiKeyEnv === engine.apiKeyEnv) ?? exact.find((p) => !p.apiKeyEnv && !engine.apiKeyEnv) ?? exact[0];
+  }
+  let host = "";
+  try {
+    host = new URL(engine.baseUrl.trim()).hostname.toLowerCase();
+  } catch {
+  }
+  if (host) {
+    const sameHost = sameKind.find((p) => p.family === "cloud" && new URL(p.baseUrl).hostname.toLowerCase() === host);
+    if (sameHost) {
+      return sameHost;
+    }
+  }
+  return engine.kind !== "openai-compatible" && sameKind.length === 1 ? sameKind[0] : void 0;
+}
+var AI_LOCAL_DETECT_TIMEOUT_MS = 1500;
+function localDetectCandidates(presets = AI_ENGINE_PRESETS) {
+  return presets.filter((p) => p.family === "local" && p.id !== "custom").map((p) => ({ presetId: p.id, baseUrl: p.baseUrl }));
+}
+
+// src/ai/discovery.ts
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function dataArray(body, key = "data") {
+  if (!isObject(body) || !Array.isArray(body[key])) {
+    return [];
+  }
+  return body[key].filter(isObject);
+}
+function drafterArch(v) {
+  return typeof v === "string" && /_mtp$/i.test(v);
+}
+function moeArch(v) {
+  return typeof v === "string" && /moe/i.test(v);
+}
+function positiveInt(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.floor(v) : void 0;
+}
+function parseOpenAiModelList(body) {
+  return dataArray(body).filter((m) => typeof m.id === "string" && m.id).map((m) => ({ id: m.id, capabilities: {}, source: "heuristic" }));
+}
+function parseLmStudioModels(body) {
+  const out = [];
+  for (const m of dataArray(body)) {
+    if (typeof m.id !== "string" || !m.id) {
+      continue;
+    }
+    const caps = {};
+    if (m.type === "embeddings") {
+      Object.assign(caps, { chat: false, stream: false, vision: false, tools: false, json: false, embed: true });
+    } else if (m.type === "vlm") {
+      Object.assign(caps, { chat: true, vision: true, embed: false });
+    } else if (m.type === "llm") {
+      Object.assign(caps, { chat: true, vision: false, embed: false });
+    }
+    if (Array.isArray(m.capabilities) && m.capabilities.includes("tool_use")) {
+      caps.tools = true;
+    }
+    if (drafterArch(m.arch)) {
+      Object.assign(caps, { chat: false, stream: false, vision: false, tools: false, json: false, embed: false });
+    }
+    const ctx = positiveInt(m.max_context_length) ?? positiveInt(m.loaded_context_length);
+    if (ctx) {
+      caps.contextTokens = ctx;
+    }
+    const model = { id: m.id, capabilities: caps, source: "endpoint" };
+    if (typeof m.state === "string") {
+      model.loaded = m.state === "loaded";
+    }
+    if (moeArch(m.arch)) {
+      model.moe = true;
+    }
+    out.push(model);
+  }
+  return out;
+}
+function parseOmlxModelStatus(body) {
+  const out = [];
+  for (const m of dataArray(body, "models")) {
+    if (typeof m.id !== "string" || !m.id) {
+      continue;
+    }
+    const caps = {};
+    if (m.model_type === "llm") {
+      Object.assign(caps, { chat: true, vision: false, embed: false });
+    } else if (m.model_type === "vlm") {
+      Object.assign(caps, { chat: true, vision: true, embed: false });
+    } else if (m.model_type === "embedding" || m.model_type === "embeddings") {
+      Object.assign(caps, { chat: false, stream: false, vision: false, tools: false, json: false, embed: true });
+    } else if (typeof m.model_type === "string") {
+      Object.assign(caps, { chat: false, stream: false, vision: false, tools: false, json: false, embed: false });
+    }
+    if (drafterArch(m.config_model_type)) {
+      Object.assign(caps, { chat: false, stream: false, vision: false, tools: false, json: false, embed: false });
+    }
+    const ctx = positiveInt(m.model_context_length);
+    if (ctx) {
+      caps.contextTokens = ctx;
+    }
+    const model = { id: m.id, capabilities: caps, source: Object.keys(caps).length > 0 ? "endpoint" : "heuristic" };
+    if (typeof m.loaded === "boolean") {
+      model.loaded = m.loaded;
+    }
+    const size = positiveInt(m.estimated_size);
+    if (size) {
+      model.sizeBytes = size;
+    }
+    if (moeArch(m.config_model_type)) {
+      model.moe = true;
+    }
+    out.push(model);
+  }
+  return out;
+}
+function withModelStatus(listed, status) {
+  const byId = new Map(status.map((s) => [s.id, s]));
+  return listed.map((m) => {
+    const s = byId.get(m.id);
+    if (!s) {
+      return m;
+    }
+    const next = { ...m, capabilities: { ...m.capabilities, ...s.capabilities } };
+    if (s.source === "endpoint") {
+      next.source = "endpoint";
+    }
+    if (s.loaded !== void 0) {
+      next.loaded = s.loaded;
+    }
+    if (s.sizeBytes !== void 0) {
+      next.sizeBytes = s.sizeBytes;
+    }
+    if (s.moe) {
+      next.moe = true;
+    }
+    return next;
+  });
+}
+function parseModelSizes(body) {
+  const out = /* @__PURE__ */ new Map();
+  for (const m of dataArray(body, "models")) {
+    const id = [m.key, m.model, m.name].find((v) => typeof v === "string" && v.length > 0);
+    const size = positiveInt(m.size_bytes) ?? positiveInt(m.size);
+    if (id && size) {
+      out.set(id, size);
+    }
+  }
+  return out;
+}
+function withModelSizes(models, sizes) {
+  return models.map((m) => {
+    const size = sizes.get(m.id);
+    return size ? { ...m, sizeBytes: size } : m;
+  });
+}
+function parseOllamaTags(body) {
+  return dataArray(body, "models").map((m) => typeof m.model === "string" && m.model ? m.model : m.name).filter((n) => typeof n === "string" && n.length > 0);
+}
+function parseOllamaShow(name, body) {
+  const caps = {};
+  if (!isObject(body)) {
+    return { id: name, capabilities: caps, source: "heuristic" };
+  }
+  if (Array.isArray(body.capabilities)) {
+    const list = body.capabilities.filter((c) => typeof c === "string");
+    caps.chat = list.includes("completion");
+    caps.stream = caps.chat;
+    caps.vision = list.includes("vision");
+    caps.tools = list.includes("tools");
+    caps.embed = list.includes("embedding");
+    caps.fim = list.includes("insert");
+  }
+  if (isObject(body.model_info)) {
+    const info = body.model_info;
+    const arch = typeof info["general.architecture"] === "string" ? info["general.architecture"] : null;
+    const ctx = (arch ? positiveInt(info[`${arch}.context_length`]) : void 0) ?? positiveInt(Object.entries(info).find(([k]) => k.endsWith(".context_length"))?.[1]);
+    if (ctx) {
+      caps.contextTokens = ctx;
+    }
+  }
+  return { id: name, capabilities: caps, source: Object.keys(caps).length > 0 ? "endpoint" : "heuristic" };
+}
+function parseOllamaRunning(body) {
+  return new Set(parseOllamaTags(body));
+}
+function parseAnthropicModels(body) {
+  const out = [];
+  for (const m of dataArray(body)) {
+    if (typeof m.id !== "string" || !m.id) {
+      continue;
+    }
+    const caps = { chat: true, stream: true, tools: true, fim: false, embed: false };
+    const ctx = positiveInt(m.max_input_tokens);
+    if (ctx) {
+      caps.contextTokens = ctx;
+    }
+    const tree = isObject(m.capabilities) ? m.capabilities : null;
+    const supported = (key) => {
+      const node = tree?.[key];
+      return isObject(node) && typeof node.supported === "boolean" ? node.supported : void 0;
+    };
+    const vision = supported("image_input");
+    if (vision !== void 0) {
+      caps.vision = vision;
+    }
+    const json = supported("structured_outputs");
+    if (json !== void 0) {
+      caps.json = json;
+    }
+    const model = { id: m.id, capabilities: caps, source: "endpoint" };
+    if (typeof m.display_name === "string" && m.display_name) {
+      model.label = m.display_name;
+    }
+    out.push(model);
+  }
+  return out;
+}
+function anthropicNextPage(body) {
+  return isObject(body) && body.has_more === true && typeof body.last_id === "string" ? body.last_id : null;
+}
+function localDetectUrl(baseUrl, detectPath) {
+  const base = baseUrl.trim().replace(/\/+$/, "");
+  return detectPath ? `${base.replace(/\/v1$/, "")}${detectPath}` : `${base}/models`;
+}
+function countDetectedModels(body) {
+  if (!isObject(body)) {
+    return void 0;
+  }
+  if (Array.isArray(body.data)) {
+    return dataArray(body).filter((m) => m.type !== "embeddings").length;
+  }
+  if (Array.isArray(body.models)) {
+    return dataArray(body, "models").length;
+  }
+  return void 0;
+}
+function localDetectTarget(candidate, presets = AI_ENGINE_PRESETS) {
+  const preset = presets.find((p) => p.id === candidate.presetId);
+  if (!preset || preset.family !== "local" || preset.id === "custom") {
+    return null;
+  }
+  const baseUrl = typeof candidate.baseUrl === "string" ? candidate.baseUrl.trim() : "";
+  if (!/^https?:\/\/[^/]/i.test(baseUrl)) {
+    return null;
+  }
+  const target = { presetId: preset.id, baseUrl, url: localDetectUrl(baseUrl, preset.detectPath), kind: preset.kind };
+  const own = baseUrl.replace(/\/+$/, "").toLowerCase() === preset.baseUrl.replace(/\/+$/, "").toLowerCase();
+  if (own && preset.apiKeyEnv) {
+    target.apiKeyEnv = preset.apiKeyEnv;
+  }
+  if (own && preset.apiKeyFile) {
+    target.apiKeyFile = { ...preset.apiKeyFile };
+  }
+  return target;
+}
+
+// src/ai/schema.ts
+var AI_SETTINGS_KEYS = ["enabled", "allowCloud", "engines", "routing", "features", "localNetworks", "showToolbarButton"];
+function isKnownEngineKind(kind) {
+  return AI_ENGINE_KINDS.includes(kind);
+}
+function isHostEngineKind(kind) {
+  return AI_HOST_ENGINE_KINDS.includes(kind);
+}
+function isObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function extras(raw, known) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (!known.includes(k)) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function randomSuffix(length) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const bytes = new Uint8Array(length);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes, (b) => alphabet[b % alphabet.length]).join("");
+}
+function generateAiId(name = "") {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24).replace(/-+$/, "");
+  return slug ? `${slug}-${randomSuffix(6)}` : `engine-${randomSuffix(8)}`;
+}
+function parseAiSettings(raw, opts = {}) {
+  const warn = opts.onWarning ?? ((m) => console.warn(`[mikedown ai] ${m}`));
+  const genId = opts.generateId ?? generateAiId;
+  const defaults = defaultAiSettings();
+  if (!isObject2(raw)) {
+    if (raw !== void 0 && raw !== null) {
+      warn("AI settings are not an object; using defaults.");
+    }
+    return defaults;
+  }
+  const source = unflatten(raw);
+  const out = { ...extras(source, AI_SETTINGS_KEYS), ...defaults };
+  if (typeof source.enabled === "boolean") {
+    out.enabled = source.enabled;
+  }
+  if (typeof source.allowCloud === "boolean") {
+    out.allowCloud = source.allowCloud;
+  }
+  if (typeof source.showToolbarButton === "boolean") {
+    out.showToolbarButton = source.showToolbarButton;
+  }
+  if (Array.isArray(source.localNetworks)) {
+    out.localNetworks = source.localNetworks.filter((n) => typeof n === "string" && n.trim().length > 0);
+  } else if (source.localNetworks !== void 0) {
+    warn("localNetworks is not an array; using the default.");
+  }
+  out.engines = parseEngines(source.engines, genId, warn);
+  out.routing = parseRouting(source.routing, warn);
+  out.features = parseFeatures(source.features, warn);
+  return out;
+}
+function unflatten(raw) {
+  const prefixed = Object.keys(raw).filter((k) => k.startsWith("ai."));
+  if (prefixed.length === 0) {
+    return isObject2(raw.ai) ? raw.ai : raw;
+  }
+  const out = {};
+  for (const k of prefixed) {
+    out[k.slice(3)] = raw[k];
+  }
+  return out;
+}
+var ENGINE_KEYS = ["id", "name", "kind", "baseUrl", "enabled", "locality", "apiKeyEnv", "apiKeyFile", "discovery", "models"];
+function parseApiKeyFile(raw) {
+  if (!isObject2(raw) || typeof raw.path !== "string" || typeof raw.jsonPath !== "string") {
+    return void 0;
+  }
+  const path = raw.path.trim();
+  const jsonPath = raw.jsonPath.trim();
+  return path && jsonPath ? { ...extras(raw, ["path", "jsonPath"]), path, jsonPath } : void 0;
+}
+function parseEngines(raw, genId, warn) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    warn("engines is not an array; ignoring it.");
+    return [];
+  }
+  const engines = [];
+  const ids = /* @__PURE__ */ new Set();
+  raw.forEach((entry, index) => {
+    if (!isObject2(entry) || typeof entry.baseUrl !== "string") {
+      warn(`engines[${index}] has no baseUrl; dropped.`);
+      return;
+    }
+    const name = typeof entry.name === "string" && entry.name.trim() ? entry.name : entry.baseUrl;
+    let kind = typeof entry.kind === "string" ? entry.kind : "openai-compatible";
+    if (!kind.trim()) {
+      kind = "openai-compatible";
+    }
+    let id = typeof entry.id === "string" && entry.id.trim() ? entry.id : "";
+    if (!id || ids.has(id)) {
+      if (id) {
+        warn(`engines[${index}] repeats id "${id}"; gave it a new one.`);
+      }
+      do {
+        id = genId(name);
+      } while (ids.has(id));
+    }
+    ids.add(id);
+    const engine = { ...extras(entry, ENGINE_KEYS) };
+    engine.id = id;
+    engine.name = name;
+    engine.kind = kind;
+    engine.baseUrl = entry.baseUrl.trim();
+    engine.enabled = typeof entry.enabled === "boolean" ? entry.enabled : true;
+    engine.locality = entry.locality === "local" || entry.locality === "cloud" ? entry.locality : "auto";
+    if (typeof entry.apiKeyEnv === "string" && entry.apiKeyEnv.trim()) {
+      engine.apiKeyEnv = entry.apiKeyEnv.trim();
+    }
+    if (entry.apiKeyFile !== void 0) {
+      const file = parseApiKeyFile(entry.apiKeyFile);
+      if (file) {
+        engine.apiKeyFile = file;
+      } else {
+        warn(`engines[${index}].apiKeyFile needs a path and a jsonPath (both strings); dropped.`);
+      }
+    }
+    engine.discovery = entry.discovery === "manual" ? "manual" : "auto";
+    engine.models = parseModels(entry.models, engine.kind, `engines[${index}]`, warn);
+    engines.push(engine);
+  });
+  return engines;
+}
+var MODEL_KEYS = ["id", "label", "enabled", "capabilities", "capabilitiesSource", "requestOverrides", "missing", "manual"];
+var CAPABILITY_SOURCES = ["endpoint", "heuristic", "user"];
+function parseModels(raw, kind, where, warn) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    warn(`${where}.models is not an array; ignoring it.`);
+    return [];
+  }
+  const models = [];
+  const ids = /* @__PURE__ */ new Set();
+  raw.forEach((entry, index) => {
+    if (!isObject2(entry) || typeof entry.id !== "string" || !entry.id.trim()) {
+      warn(`${where}.models[${index}] has no id; dropped.`);
+      return;
+    }
+    if (ids.has(entry.id)) {
+      warn(`${where}.models[${index}] repeats id "${entry.id}"; dropped.`);
+      return;
+    }
+    ids.add(entry.id);
+    const model = { ...extras(entry, MODEL_KEYS) };
+    model.id = entry.id;
+    if (typeof entry.label === "string" && entry.label.trim()) {
+      model.label = entry.label;
+    }
+    model.enabled = typeof entry.enabled === "boolean" ? entry.enabled : true;
+    const known = isKnownEngineKind(kind) ? kind : void 0;
+    if (isObject2(entry.capabilities)) {
+      model.capabilities = completeCapabilities(entry.capabilities, entry.id, known);
+      if (entry.capabilities.contextTokens === null) {
+        model.capabilities.contextTokens = null;
+      }
+      model.capabilitiesSource = CAPABILITY_SOURCES.includes(entry.capabilitiesSource) ? entry.capabilitiesSource : "heuristic";
+    } else {
+      model.capabilities = detectCapabilities(entry.id, known).capabilities;
+      model.capabilitiesSource = "heuristic";
+    }
+    if (isObject2(entry.requestOverrides)) {
+      model.requestOverrides = entry.requestOverrides;
+    } else if (entry.requestOverrides !== void 0) {
+      warn(`${where}.models[${index}].requestOverrides is not an object; ignoring it.`);
+    }
+    if (entry.missing === true) {
+      model.missing = true;
+    }
+    if (entry.manual === true) {
+      model.manual = true;
+    }
+    models.push(model);
+  });
+  return models;
+}
+function parseRoute(raw) {
+  if (!isObject2(raw) || typeof raw.engineId !== "string" || typeof raw.modelId !== "string" || !raw.engineId || !raw.modelId) {
+    return null;
+  }
+  return { ...raw, engineId: raw.engineId, modelId: raw.modelId };
+}
+function parseRouting(raw, warn) {
+  const routing = { default: null, fallback: "anyLocal", tasks: {} };
+  if (raw === void 0) {
+    return routing;
+  }
+  if (!isObject2(raw)) {
+    warn("routing is not an object; using the defaults.");
+    return routing;
+  }
+  const out = { ...extras(raw, ["default", "fallback", "tasks"]), ...routing };
+  if (raw.default !== void 0 && raw.default !== null) {
+    out.default = parseRoute(raw.default);
+    if (!out.default) {
+      warn("routing.default needs engineId and modelId; cleared.");
+    }
+  }
+  if (typeof raw.fallback === "string" && AI_FALLBACK_MODES.includes(raw.fallback)) {
+    out.fallback = raw.fallback;
+  } else if (raw.fallback !== void 0) {
+    warn(`routing.fallback "${String(raw.fallback)}" is not a fallback mode; using anyLocal.`);
+  }
+  if (isObject2(raw.tasks)) {
+    for (const [task, value] of Object.entries(raw.tasks)) {
+      const route = parseRoute(value);
+      if (route) {
+        out.tasks[task] = route;
+      } else if (value !== null) {
+        warn(`routing.tasks.${task} needs engineId and modelId; dropped.`);
+      }
+    }
+  } else if (raw.tasks !== void 0) {
+    warn("routing.tasks is not an object; ignoring it.");
+  }
+  return out;
+}
+function parseFeatures(raw, warn) {
+  const features = {};
+  if (raw === void 0) {
+    return features;
+  }
+  if (!isObject2(raw)) {
+    warn("features is not an object; ignoring it.");
+    return features;
+  }
+  for (const [id, value] of Object.entries(raw)) {
+    if (!isObject2(value)) {
+      warn(`features.${id} is not an object; dropped.`);
+      continue;
+    }
+    const feature = { ...extras(value, ["enabled", "task"]) };
+    if (typeof value.enabled === "boolean") {
+      feature.enabled = value.enabled;
+    }
+    if (typeof value.task === "string" && value.task.trim()) {
+      feature.task = value.task;
+    }
+    features[id] = feature;
+  }
+  return features;
+}
+function serializeAiSettings(settings) {
+  const patch = {};
+  for (const [key, value] of Object.entries(settings)) {
+    if (value === void 0) {
+      continue;
+    }
+    patch[`ai.${key}`] = JSON.parse(JSON.stringify(value));
+  }
+  return patch;
+}
+
+// src/ai/router.ts
+function isRouteUsable(r) {
+  return !("unusable" in r);
+}
+var CAPABILITY_LABELS = {
+  chat: "chat",
+  stream: "streaming",
+  vision: "vision",
+  json: "JSON output",
+  tools: "tools",
+  fim: "fill-in-the-middle",
+  embed: "embeddings",
+  contextTokens: "a large enough context window"
+};
+function engineLabel(engine) {
+  return engine.name || engine.id;
+}
+function modelLabel(model) {
+  return model.label || model.id;
+}
+function resolveRoute(settings, statuses, consent, opts) {
+  if (!settings.enabled) {
+    return { unusable: "aiDisabled", reason: "AI is turned off." };
+  }
+  const feature = resolveAiFeature(settings.features, opts.feature);
+  const task = opts.task ?? feature.task;
+  if (!feature.enabled) {
+    return { unusable: "featureDisabled", reason: `${feature.definition?.label ?? opts.feature} is turned off.`, task };
+  }
+  const taskDef = getAiTask(task);
+  const requires = combineRequirements(taskDef?.requires ?? {}, feature.requires);
+  const requiresAny = taskDef?.requiresAny;
+  const prefers = taskDef?.prefers;
+  const statusById = new Map(statuses.map((s) => [s.engineId, s]));
+  const check = (route) => checkCandidate(settings, statusById, consent, route, requires, requiresAny);
+  const preferred = settings.routing.tasks[task] ?? settings.routing.default;
+  if (!preferred) {
+    return fallbackFrom(null, { code: "noRoute", reason: "No engine and model is chosen for this task." });
+  }
+  const first = check(preferred);
+  if (!("code" in first)) {
+    return ok(first, false);
+  }
+  return fallbackFrom(preferred, first);
+  function ok(c, viaFallback, reason) {
+    const result = { engineId: c.engine.id, modelId: c.model.id, viaFallback, task, isLocal: c.isLocal, needsConsent: c.needsConsent };
+    if (reason) {
+      result.reason = reason;
+    }
+    return result;
+  }
+  function fallbackFrom(primary, rejection) {
+    const mode = settings.routing.fallback;
+    if (mode === "none") {
+      return unusableFrom(rejection);
+    }
+    const primaryEngine = primary ? settings.engines.find((e) => e.id === primary.engineId) : void 0;
+    const primaryIsLocal = primaryEngine ? engineLocality(primaryEngine, settings.localNetworks) === "local" : true;
+    const allowsCloud = (c) => c.isLocal || !primaryIsLocal || mode === "any";
+    const tried = /* @__PURE__ */ new Set();
+    if (primary) {
+      tried.add(routeKey(primary));
+    }
+    const tier = [];
+    const def = settings.routing.default;
+    if (def && !tried.has(routeKey(def))) {
+      tried.add(routeKey(def));
+      const c = check(def);
+      if (!("code" in c) && allowsCloud(c)) {
+        tier.push(c);
+      }
+    }
+    if (mode === "default") {
+      const only = preferFirst(tier, prefers);
+      return only ? ok(only, true, rejection.reason) : unusableFrom(rejection);
+    }
+    const scan = (wantLocal) => {
+      const found = [];
+      for (const engine of settings.engines) {
+        for (const model of engine.models) {
+          const route = { engineId: engine.id, modelId: model.id };
+          if (tried.has(routeKey(route))) {
+            continue;
+          }
+          const c = check(route);
+          if ("code" in c || c.isLocal !== wantLocal) {
+            continue;
+          }
+          found.push(c);
+        }
+      }
+      return found;
+    };
+    const pick = preferFirst([...tier, ...scan(true)], prefers);
+    if (pick) {
+      return ok(pick, true, rejection.reason);
+    }
+    if (mode === "any") {
+      const cloud = preferFirst(scan(false), prefers);
+      if (cloud) {
+        return ok(cloud, true, rejection.reason);
+      }
+    }
+    return unusableFrom(rejection);
+  }
+  function unusableFrom(rejection) {
+    return { unusable: rejection.code, reason: rejection.reason, task, ...rejection.engineId ? { engineId: rejection.engineId } : {} };
+  }
+}
+function preferFirst(candidates, prefers) {
+  if (candidates.length === 0) {
+    return null;
+  }
+  if (prefers) {
+    const match = candidates.find((c) => missingCapabilities(c.model.capabilities, prefers).length === 0);
+    if (match) {
+      return match;
+    }
+  }
+  return candidates[0];
+}
+function routeKey(r) {
+  return `${r.engineId}\0${r.modelId}`;
+}
+function checkCandidate(settings, statusById, consent, route, requires, requiresAny) {
+  const engine = settings.engines.find((e) => e.id === route.engineId);
+  if (!engine) {
+    return { code: "engineMissing", reason: "The routed engine no longer exists." };
+  }
+  const name = engineLabel(engine);
+  const engineId = engine.id;
+  if (!engine.enabled) {
+    return { code: "engineDisabled", reason: `${name} is turned off.`, engineId };
+  }
+  if (!isKnownEngineKind(engine.kind)) {
+    return { code: "engineUnsupported", reason: `${name} uses an engine kind this version does not support.` };
+  }
+  const status = statusById.get(engine.id);
+  if (isHostEngineKind(engine.kind) && !status) {
+    return { code: "engineUnsupported", reason: `${name} uses an engine kind this app does not support.` };
+  }
+  const model = engine.models.find((m) => m.id === route.modelId);
+  if (!model) {
+    return { code: "modelMissing", reason: `${name} has no model "${route.modelId}".`, engineId };
+  }
+  if (!model.enabled) {
+    return { code: "modelDisabled", reason: `${modelLabel(model)} is turned off.` };
+  }
+  if (model.missing || status?.models.find((m) => m.id === model.id)?.missing) {
+    return { code: "modelNotListed", reason: `${name} no longer lists ${modelLabel(model)}.`, engineId };
+  }
+  const lacking = missingCapabilities(model.capabilities, requires, requiresAny);
+  if (lacking.length > 0) {
+    return { code: "capability", reason: `${modelLabel(model)} lacks ${lacking.map((c) => CAPABILITY_LABELS[c] ?? c).join(", ")}.` };
+  }
+  const isLocal = engineLocality(engine, settings.localNetworks) === "local";
+  let needsConsent = false;
+  if (!isLocal) {
+    if (!settings.allowCloud) {
+      return { code: "cloudBlocked", reason: `${name} is a cloud engine and Allow cloud is off.` };
+    }
+    const answer = consent[engine.id];
+    if (answer === false) {
+      return { code: "consentDenied", reason: `${name} was not allowed in this workspace.` };
+    }
+    needsConsent = answer !== true;
+  }
+  if (status?.ok === false) {
+    return { code: "probeFailed", reason: status.error ? `${name} failed its last connection test: ${status.error}` : `${name} failed its last connection test.`, engineId };
+  }
+  return { engine, model, isLocal, needsConsent };
+}
+
+// src/ai/sse.ts
+var SseParser = class {
+  constructor() {
+    this.buffer = "";
+    this.started = false;
+    this.dataLines = [];
+  }
+  /** Feed decoded text; returns the events it completed. */
+  push(chunk) {
+    let text = chunk;
+    if (!this.started && text.length > 0) {
+      this.started = true;
+      if (text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+    }
+    this.buffer += text;
+    const events = [];
+    for (; ; ) {
+      const match = /\r\n|\r|\n/.exec(this.buffer);
+      if (!match) {
+        break;
+      }
+      if (match[0] === "\r" && match.index === this.buffer.length - 1) {
+        break;
+      }
+      const line = this.buffer.slice(0, match.index);
+      this.buffer = this.buffer.slice(match.index + match[0].length);
+      const event = this.line(line);
+      if (event) {
+        events.push(event);
+      }
+    }
+    return events;
+  }
+  /** The stream closed: flush a final event that had no trailing blank line. */
+  end() {
+    const events = [];
+    if (this.buffer.length > 0) {
+      const rest = this.buffer.replace(/\r$/, "");
+      this.buffer = "";
+      const event = this.line(rest);
+      if (event) {
+        events.push(event);
+      }
+    }
+    const last = this.line("");
+    if (last) {
+      events.push(last);
+    }
+    return events;
+  }
+  line(line) {
+    if (line === "") {
+      if (this.dataLines.length === 0) {
+        this.eventName = void 0;
+        return null;
+      }
+      const event = { data: this.dataLines.join("\n") };
+      if (this.eventName) {
+        event.event = this.eventName;
+      }
+      if (this.lastId !== void 0) {
+        event.id = this.lastId;
+      }
+      this.dataLines = [];
+      this.eventName = void 0;
+      return event;
+    }
+    if (line.startsWith(":")) {
+      return null;
+    }
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) {
+      value = value.slice(1);
+    }
+    if (field === "data") {
+      this.dataLines.push(value);
+    } else if (field === "event") {
+      this.eventName = value;
+    } else if (field === "id" && !value.includes("\0")) {
+      this.lastId = value;
+    }
+    return null;
+  }
+};
+function parseJson(data) {
+  try {
+    const v = JSON.parse(data);
+    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function errorCodeFromType(type) {
+  switch (type) {
+    case "authentication_error":
+    case "permission_error":
+    case "invalid_api_key":
+      return "auth";
+    case "not_found_error":
+    case "model_not_found":
+      return "modelNotFound";
+    case "rate_limit_error":
+    case "overloaded_error":
+    case "rate_limit_exceeded":
+      return "rateLimited";
+    case "context_length_exceeded":
+    case "request_too_large":
+      return "contextOverflow";
+    default:
+      return "unknown";
+  }
+}
+function streamError(raw) {
+  const e = typeof raw === "object" && raw !== null ? raw : {};
+  const message = typeof e.message === "string" ? e.message : typeof raw === "string" ? raw : "The stream reported an error.";
+  return { code: errorCodeFromType(e.type ?? e.code), message };
+}
+function mapOpenAiFinish(reason) {
+  if (reason === "length") {
+    return "length";
+  }
+  if (reason === "stop" || reason === "tool_calls" || reason === "function_call" || reason === "eos") {
+    return "stop";
+  }
+  return "error";
+}
+function mapAnthropicStop(reason) {
+  if (reason === "max_tokens" || reason === "model_context_window_exceeded") {
+    return "length";
+  }
+  if (reason === "end_turn" || reason === "stop_sequence" || reason === "tool_use" || reason === "pause_turn") {
+    return "stop";
+  }
+  return "error";
+}
+function createOpenAiStreamReader() {
+  const parser = new SseParser();
+  let text = "";
+  let reasoningChars = 0;
+  let done = false;
+  let stopReason;
+  let usage;
+  let error;
+  const handle = (events) => {
+    const deltas = [];
+    for (const ev of events) {
+      const data = ev.data.trim();
+      if (data === "[DONE]") {
+        done = true;
+        continue;
+      }
+      const json = parseJson(data);
+      if (!json) {
+        continue;
+      }
+      if (json.error !== void 0) {
+        error = streamError(json.error);
+        continue;
+      }
+      const u = json.usage;
+      if (u && typeof u === "object") {
+        usage = { promptTokens: num(u.prompt_tokens), completionTokens: num(u.completion_tokens) };
+      }
+      const choices = Array.isArray(json.choices) ? json.choices : [];
+      for (const choice of choices) {
+        const delta = choice.delta;
+        const content = delta?.content;
+        if (typeof content === "string" && content) {
+          text += content;
+          deltas.push(content);
+        }
+        const reasoning = delta?.reasoning_content ?? delta?.reasoning;
+        if (typeof reasoning === "string") {
+          reasoningChars += reasoning.length;
+        }
+        if (typeof choice.finish_reason === "string" && choice.finish_reason) {
+          stopReason = choice.finish_reason;
+        }
+      }
+    }
+    return deltas;
+  };
+  return {
+    push: (chunk) => handle(parser.push(chunk)),
+    outputChars: () => text.length + reasoningChars,
+    finish() {
+      handle(parser.end());
+      let finishReason;
+      if (error) {
+        finishReason = "error";
+      } else if (!done) {
+        finishReason = "error";
+      } else {
+        finishReason = stopReason ? mapOpenAiFinish(stopReason) : "stop";
+      }
+      const outcome = { text, finishReason };
+      if (usage) {
+        outcome.usage = usage;
+      }
+      if (stopReason) {
+        outcome.stopReason = stopReason;
+      }
+      if (error) {
+        outcome.error = error;
+      }
+      return outcome;
+    }
+  };
+}
+function createAnthropicStreamReader() {
+  const parser = new SseParser();
+  let text = "";
+  let thinkingChars = 0;
+  let done = false;
+  let stopReason;
+  let promptTokens;
+  let completionTokens;
+  let error;
+  const handle = (events) => {
+    const deltas = [];
+    for (const ev of events) {
+      const json = parseJson(ev.data);
+      if (!json) {
+        continue;
+      }
+      const type = typeof json.type === "string" ? json.type : ev.event;
+      switch (type) {
+        case "message_start": {
+          const message = json.message;
+          const u = message?.usage;
+          promptTokens = num(u?.input_tokens) ?? promptTokens;
+          completionTokens = num(u?.output_tokens) ?? completionTokens;
+          break;
+        }
+        case "content_block_delta": {
+          const delta = json.delta;
+          if (delta?.type === "text_delta" && typeof delta.text === "string" && delta.text) {
+            text += delta.text;
+            deltas.push(delta.text);
+          } else if (delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
+            thinkingChars += delta.thinking.length;
+          }
+          break;
+        }
+        case "message_delta": {
+          const delta = json.delta;
+          if (typeof delta?.stop_reason === "string") {
+            stopReason = delta.stop_reason;
+          }
+          const u = json.usage;
+          promptTokens = num(u?.input_tokens) ?? promptTokens;
+          completionTokens = num(u?.output_tokens) ?? completionTokens;
+          break;
+        }
+        case "message_stop":
+          done = true;
+          break;
+        case "error":
+          error = streamError(json.error);
+          break;
+        default:
+          break;
+      }
+    }
+    return deltas;
+  };
+  return {
+    push: (chunk) => handle(parser.push(chunk)),
+    outputChars: () => text.length + thinkingChars,
+    finish() {
+      handle(parser.end());
+      let finishReason;
+      if (error || !done) {
+        finishReason = "error";
+      } else {
+        finishReason = stopReason ? mapAnthropicStop(stopReason) : "stop";
+      }
+      const outcome = { text, finishReason };
+      if (promptTokens !== void 0 || completionTokens !== void 0) {
+        outcome.usage = { promptTokens, completionTokens };
+      }
+      if (stopReason) {
+        outcome.stopReason = stopReason;
+      }
+      if (error) {
+        outcome.error = error;
+      }
+      return outcome;
+    }
+  };
+}
+function createCompletionStreamReader(kind) {
+  return kind === "anthropic" ? createAnthropicStreamReader() : createOpenAiStreamReader();
+}
+
+// src/ai/stats.ts
+var AI_CHARS_PER_TOKEN = 4;
+function positive(n) {
+  return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function aiResultStats(result) {
+  const t = result.timing;
+  if (!t || typeof t.totalMs !== "number" || !Number.isFinite(t.totalMs) || t.totalMs < 0) {
+    return null;
+  }
+  const stats = { totalMs: t.totalMs, approximate: false };
+  if (typeof t.firstTokenMs === "number" && Number.isFinite(t.firstTokenMs) && t.firstTokenMs >= 0) {
+    stats.firstTokenMs = t.firstTokenMs;
+  }
+  const reported = positive(result.usage?.completionTokens);
+  if (reported !== void 0) {
+    stats.outputTokens = reported;
+  } else {
+    const chars = t.outputChars ?? result.text.length;
+    if (chars > 0) {
+      stats.outputTokens = Math.max(1, Math.round(chars / AI_CHARS_PER_TOKEN));
+      stats.approximate = true;
+    }
+  }
+  const input = positive(result.usage?.promptTokens);
+  if (input !== void 0) {
+    stats.inputTokens = input;
+  }
+  const first = stats.firstTokenMs;
+  const generationMs = first !== void 0 && t.totalMs > first ? t.totalMs - first : t.totalMs;
+  if (stats.outputTokens !== void 0 && generationMs > 0) {
+    stats.tokensPerSecond = stats.outputTokens / (generationMs / 1e3);
+  }
+  return stats;
+}
+function formatAiSeconds(ms) {
+  const s = ms / 1e3;
+  return s < 10 ? `${s.toFixed(1)} s` : `${Math.round(s)} s`;
+}
+function formatAiTokensPerSecond(tps, approximate) {
+  const n = tps < 10 ? tps.toFixed(1) : String(Math.round(tps));
+  return `${approximate ? "~" : ""}${n} tok/s`;
+}
+function aiResultStatsText(stats) {
+  const time = formatAiSeconds(stats.totalMs);
+  return stats.tokensPerSecond === void 0 ? time : `${time} \xB7 ${formatAiTokensPerSecond(stats.tokensPerSecond, stats.approximate)}`;
+}
+function aiResultStatsTitle(stats) {
+  const lines = [];
+  if (stats.firstTokenMs !== void 0) {
+    lines.push(`First token after ${formatAiSeconds(stats.firstTokenMs)}`);
+  }
+  lines.push(`Total ${formatAiSeconds(stats.totalMs)}`);
+  if (stats.outputTokens !== void 0) {
+    lines.push(stats.approximate ? `About ${stats.outputTokens.toLocaleString("en-US")} output tokens (estimated from the text)` : `${stats.outputTokens.toLocaleString("en-US")} output tokens`);
+  }
+  if (stats.inputTokens !== void 0) {
+    lines.push(`${stats.inputTokens.toLocaleString("en-US")} input tokens`);
+  }
+  if (stats.tokensPerSecond !== void 0) {
+    lines.push(formatAiTokensPerSecond(stats.tokensPerSecond, stats.approximate));
+  }
+  return lines.join("\n");
+}
+function aiTimingLogParts(result) {
+  const stats = aiResultStats(result);
+  if (!stats) {
+    return [];
+  }
+  const parts = [];
+  if (stats.firstTokenMs !== void 0) {
+    parts.push(`first token ${Math.round(stats.firstTokenMs)} ms`);
+  }
+  if (stats.tokensPerSecond !== void 0) {
+    parts.push(formatAiTokensPerSecond(stats.tokensPerSecond, stats.approximate));
+  }
+  return parts;
+}
+
+// src/ai/requests.ts
+var ANTHROPIC_API_VERSION = "2026-10-21";
+var ANTHROPIC_DEFAULT_MAX_TOKENS = 4096;
+var JSON_ONLY_INSTRUCTION = "Respond with a single valid JSON value and nothing else.";
+function trimSlash(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+function engineEndpoints(engine) {
+  const base = trimSlash(engine.baseUrl);
+  const root = base.replace(/\/v1$/, "");
+  const v1 = `${root}/v1`;
+  switch (engine.kind) {
+    case "anthropic":
+      return { completions: `${v1}/messages`, models: `${v1}/models` };
+    case "lmstudio":
+      return { completions: `${v1}/chat/completions`, models: `${v1}/models`, embeddings: `${v1}/embeddings`, nativeModels: `${root}/api/v0/models` };
+    case "ollama":
+      return {
+        completions: `${v1}/chat/completions`,
+        models: `${v1}/models`,
+        embeddings: `${v1}/embeddings`,
+        nativeModels: `${root}/api/tags`,
+        nativeShow: `${root}/api/show`
+      };
+    default:
+      return { completions: `${base}/chat/completions`, models: `${base}/models`, embeddings: `${base}/embeddings` };
+  }
+}
+function buildAuthHeaders(kind, apiKey) {
+  const headers = { "content-type": "application/json" };
+  if (kind === "anthropic") {
+    headers["anthropic-version"] = ANTHROPIC_API_VERSION;
+    if (apiKey) {
+      headers["x-api-key"] = apiKey;
+    }
+  } else if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeRequestOverrides(body, overrides) {
+  if (!overrides) {
+    return body;
+  }
+  const out = { ...body };
+  for (const [key, value] of Object.entries(overrides)) {
+    const current = out[key];
+    out[key] = isPlainObject(current) && isPlainObject(value) ? mergeRequestOverrides(current, value) : value;
+  }
+  return out;
+}
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let out = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out += BASE64_ALPHABET[n >> 18 & 63] + BASE64_ALPHABET[n >> 12 & 63] + BASE64_ALPHABET[n >> 6 & 63] + BASE64_ALPHABET[n & 63];
+  }
+  const rest = bytes.length - i;
+  if (rest === 1) {
+    const n = bytes[i] << 16;
+    out += `${BASE64_ALPHABET[n >> 18 & 63]}${BASE64_ALPHABET[n >> 12 & 63]}==`;
+  } else if (rest === 2) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8;
+    out += `${BASE64_ALPHABET[n >> 18 & 63]}${BASE64_ALPHABET[n >> 12 & 63]}${BASE64_ALPHABET[n >> 6 & 63]}=`;
+  }
+  return out;
+}
+function base64ToBytes(b64) {
+  const clean = b64.replace(/[\s=]/g, "").replace(/-/g, "+").replace(/_/g, "/");
+  const out = new Uint8Array(Math.floor(clean.length * 3 / 4));
+  let bits = 0;
+  let value = 0;
+  let o = 0;
+  for (const ch of clean) {
+    const idx = BASE64_ALPHABET.indexOf(ch);
+    if (idx === -1) {
+      continue;
+    }
+    value = value << 6 | idx;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[o++] = value >> bits & 255;
+    }
+  }
+  return out.slice(0, o);
+}
+function textOf(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n\n");
+}
+function openAiContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(
+    (part) => part.type === "text" ? { type: "text", text: part.text } : { type: "image_url", image_url: { url: `data:${part.mime};base64,${bytesToBase64(part.bytes)}` } }
+  );
+}
+function anthropicContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(
+    (part) => part.type === "text" ? { type: "text", text: part.text } : { type: "image", source: { type: "base64", media_type: part.mime, data: bytesToBase64(part.bytes) } }
+  );
+}
+function buildCompletionBody(kind, model, req, opts = {}) {
+  const stream = opts.stream ?? true;
+  const body = kind === "anthropic" ? anthropicBody(model.id, req, stream) : chatCompletionsBody(kind, model.id, req, stream);
+  const merged = mergeRequestOverrides(body, model.requestOverrides);
+  const final = isPlainObject(req.requestOverrides) ? mergeRequestOverrides(merged, req.requestOverrides) : merged;
+  return kind === "anthropic" ? final : acceptedOffEffort(kind, model.id, final);
+}
+function acceptedOffEffort(kind, modelId, body) {
+  if (body.reasoning_effort !== "none") {
+    return body;
+  }
+  const effort = openAiOffReasoningEffort(modelId, kind);
+  return effort === null || effort === "none" ? body : { ...body, reasoning_effort: effort };
+}
+function chatCompletionsBody(kind, modelId, req, stream) {
+  const body = {
+    model: modelId,
+    messages: req.messages.map((m) => ({ role: m.role, content: openAiContent(m.content) })),
+    stream
+  };
+  if (req.maxTokens !== void 0) {
+    body[kind === "openai" ? "max_completion_tokens" : "max_tokens"] = req.maxTokens;
+  }
+  if (req.temperature !== void 0 && !isOpenAiReasoningModel(modelId, kind)) {
+    body.temperature = req.temperature;
+  }
+  if (req.format === "json") {
+    body.response_format = kind === "lmstudio" ? { type: "json_schema", json_schema: { name: "response", schema: { type: "object" } } } : { type: "json_object" };
+  }
+  if (kind === "openai" && stream) {
+    body.stream_options = { include_usage: true };
+  }
+  return body;
+}
+function anthropicBody(modelId, req, stream) {
+  const system = req.messages.filter((m) => m.role === "system").map((m) => textOf(m.content));
+  if (req.format === "json") {
+    system.push(JSON_ONLY_INSTRUCTION);
+  }
+  const body = {
+    model: modelId,
+    max_tokens: req.maxTokens ?? ANTHROPIC_DEFAULT_MAX_TOKENS,
+    messages: req.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: anthropicContent(m.content) })),
+    stream
+  };
+  if (system.length > 0) {
+    body.system = system.join("\n\n");
+  }
+  return body;
+}
+var STREAM_USAGE_HOSTS = ["openrouter.ai", "generativelanguage.googleapis.com", "api.groq.com", "api.deepseek.com"];
+function streamUsageSupported(engine) {
+  switch (engine.kind) {
+    case "openai":
+    case "lmstudio":
+    case "ollama":
+      return true;
+    case "openai-compatible": {
+      if (detectLocality(engine.baseUrl) === "local") {
+        return true;
+      }
+      const host = hostOfUrl(engine.baseUrl);
+      return host !== null && STREAM_USAGE_HOSTS.includes(host);
+    }
+    default:
+      return false;
+  }
+}
+function withStreamUsage(body, engine) {
+  if (body.stream !== true || "stream_options" in body || !streamUsageSupported(engine)) {
+    return body;
+  }
+  return { ...body, stream_options: { include_usage: true } };
+}
+var RETRYABLE_REQUEST_PARAMS = [
+  "temperature",
+  "top_p",
+  "presence_penalty",
+  "frequency_penalty",
+  "max_tokens",
+  "max_completion_tokens",
+  "reasoning_effort",
+  "stream_options"
+];
+var UNSUPPORTED_WORDING = /unsupported|not supported|does not support|not compatible/i;
+function unsupportedRequestParam(status, bodyText) {
+  if (status !== 400) {
+    return null;
+  }
+  let message = bodyText;
+  let param;
+  let code;
+  try {
+    const json = JSON.parse(bodyText);
+    const error = isPlainObject(json) ? json.error : void 0;
+    if (isPlainObject(error)) {
+      message = typeof error.message === "string" ? error.message : "";
+      param = error.param;
+      code = error.code;
+    } else if (typeof error === "string") {
+      message = error;
+    } else if (isPlainObject(json) && typeof json.message === "string") {
+      message = json.message;
+    }
+  } catch {
+  }
+  if (!UNSUPPORTED_WORDING.test(`${typeof code === "string" ? code : ""} ${message}`)) {
+    return null;
+  }
+  if (typeof param === "string" && param !== "") {
+    return RETRYABLE_REQUEST_PARAMS.includes(param) ? param : null;
+  }
+  for (const match of message.matchAll(/['"`]([a-z_]+)['"`]/g)) {
+    if (RETRYABLE_REQUEST_PARAMS.includes(match[1])) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function withoutRequestParam(body, param) {
+  if (!(param in body)) {
+    return null;
+  }
+  const out = { ...body };
+  const value = out[param];
+  delete out[param];
+  const replacement = param === "max_tokens" ? "max_completion_tokens" : param === "max_completion_tokens" ? "max_tokens" : null;
+  if (replacement && !(replacement in out)) {
+    out[replacement] = value;
+  }
+  return out;
+}
+function buildEmbeddingsBody(kind, model, texts) {
+  if (kind === "anthropic") {
+    return null;
+  }
+  return mergeRequestOverrides({ model: model.id, input: texts }, model.requestOverrides);
+}
+function parseEmbeddingsResponse(body) {
+  if (!isPlainObject(body) || !Array.isArray(body.data)) {
+    return [];
+  }
+  return body.data.filter(isPlainObject).map((d, i) => ({ index: typeof d.index === "number" ? d.index : i, embedding: d.embedding })).sort((a, b) => a.index - b.index).map((d) => Array.isArray(d.embedding) ? d.embedding.filter((x) => typeof x === "number") : []);
+}
+
+// src/ai/wire.ts
+function toWireCompletionRequest(req) {
+  return {
+    ...req,
+    messages: req.messages.map((m) => ({
+      role: m.role,
+      content: typeof m.content === "string" ? m.content : m.content.map((p) => p.type === "text" ? p : { type: "image", mime: p.mime, dataBase64: bytesToBase64(p.bytes) })
+    }))
+  };
+}
+function fromWireCompletionRequest(wire) {
+  return {
+    ...wire,
+    messages: wire.messages.map((m) => ({
+      role: m.role,
+      content: typeof m.content === "string" ? m.content : m.content.map((p) => p.type === "text" ? p : { type: "image", mime: p.mime, bytes: base64ToBytes(p.dataBase64) })
+    }))
+  };
+}
+
+// src/ai/errors.ts
+var AI_ERROR_COPY = {
+  unreachable: {
+    title: "Engine not reachable",
+    message: "The AI engine did not answer. Check that the server is running and the base URL is right.",
+    action: "openSettings"
+  },
+  auth: {
+    title: "Key rejected",
+    message: "The engine refused the API key. Store a new key in AI settings, or check the environment variable.",
+    action: "openSettings"
+  },
+  modelNotFound: {
+    title: "Model not found",
+    message: "The engine does not serve this model. Refresh models or pick another one in AI settings.",
+    action: "openSettings"
+  },
+  modelLoadFailed: {
+    title: "Model didn't load",
+    message: "The engine couldn't load the model. Load it in the engine's app, or choose another model.",
+    action: "chooseModel"
+  },
+  contextOverflow: {
+    title: "Too much text",
+    message: "The text is longer than the model's context window. Try a shorter selection.",
+    action: "shortenSelection"
+  },
+  rateLimited: {
+    title: "Rate limited",
+    message: "The engine is busy or the rate limit was reached. Wait a moment and try again.",
+    action: "retry"
+  },
+  cloudBlocked: {
+    title: "Cloud engines are off",
+    message: "This task is routed to a cloud engine, and Allow cloud is off in AI settings.",
+    action: "openSettings"
+  },
+  consentDenied: {
+    title: "Not allowed in this workspace",
+    message: "Sending text to this cloud engine was not allowed for this workspace.",
+    action: "openSettings"
+  },
+  cancelled: {
+    title: "Cancelled",
+    message: "The request was cancelled."
+  },
+  badOutput: {
+    title: "No usable answer",
+    message: "The model did not return a usable answer. Try again or pick another model.",
+    action: "retry"
+  },
+  unknown: {
+    title: "Something went wrong",
+    message: "The AI request failed.",
+    action: "retry"
+  }
+};
+function aiLengthLimitCopy(opts) {
+  if (opts.empty) {
+    return opts.thinking ? { title: "No room left to answer", message: "The model used its whole length budget thinking and sent no answer. Lower Thinking, or Retry.", action: "retry" } : { title: "No room left to answer", message: "The model reached its length limit before it sent any text. Retry.", action: "retry" };
+  }
+  return opts.thinking ? { title: "Answer cut off", message: "The answer was cut off at the length limit. Lower Thinking, or Retry, for a full answer.", action: "retry" } : { title: "Answer cut off", message: "The answer was cut off at the length limit.", action: "retry" };
+}
+function isAiErrorCode(v) {
+  return typeof v === "string" && AI_ERROR_CODES.includes(v);
+}
+function isAiError(v) {
+  return typeof v === "object" && v !== null && isAiErrorCode(v.code) && typeof v.message === "string";
+}
+function makeAiError(code, message) {
+  return { code, message: message ?? AI_ERROR_COPY[code].message };
+}
+function toAiError(err) {
+  if (isAiError(err)) {
+    return { code: err.code, message: err.message, ...typeof err.engineId === "string" ? { engineId: err.engineId } : {} };
+  }
+  if (typeof err === "object" && err !== null && err.name === "AbortError") {
+    return makeAiError("cancelled");
+  }
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : AI_ERROR_COPY.unknown.message;
+  return { code: "unknown", message };
+}
+var ENGINE_COPY = {
+  unreachable: (engine) => `${engine} did not answer. Check that the server is running and the base URL is right.`,
+  auth: (engine) => `${engine} refused the API key. Store a new key, or check the environment variable.`,
+  modelNotFound: (engine) => `${engine} does not serve this model. Refresh its models or pick another one.`,
+  modelLoadFailed: (engine, model) => `${engine} couldn't load ${model}. Load it in ${engine}, or choose another model.`
+};
+function aiErrorCopy(code, opts = {}) {
+  const copy = AI_ERROR_COPY[code] ?? AI_ERROR_COPY.unknown;
+  const named = opts.engine ? ENGINE_COPY[code] : void 0;
+  if (!named || !opts.engine) {
+    return copy;
+  }
+  return { ...copy, message: named(opts.engine, opts.model || "the model"), action: copy.action === "chooseModel" ? "chooseModel" : "openEngine" };
+}
+var MODEL_LOAD_FAILED_PHRASES = [
+  "failed to load model",
+  "error loading model",
+  "unable to load model",
+  "could not load model",
+  "couldn't load model",
+  "model failed to load",
+  "llama runner process has terminated",
+  "requires more system memory"
+];
+function isModelLoadFailure(bodyText) {
+  const lower = bodyText.toLowerCase();
+  return MODEL_LOAD_FAILED_PHRASES.some((p) => lower.includes(p));
+}
+function aiErrorCodeFromHttp(status, bodyText = "") {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 404) {
+    return "modelNotFound";
+  }
+  if (isModelLoadFailure(bodyText)) {
+    return "modelLoadFailed";
+  }
+  if (status === 413) {
+    return "contextOverflow";
+  }
+  if (status === 429 || status === 529) {
+    return "rateLimited";
+  }
+  if (status === 400 && /context|too long|maximum.*tokens|token limit/i.test(bodyText)) {
+    return "contextOverflow";
+  }
+  if (status === 400 && /model.*(not found|does not exist|unknown)|no such model/i.test(bodyText)) {
+    return "modelNotFound";
+  }
+  if (status === 502 || status === 503 || status === 504) {
+    return "unreachable";
+  }
+  return "unknown";
+}
+
+// src/ai/thinking.ts
+var TIERS = ["low", "medium", "high"];
+var LABELS = { off: "Off", low: "Low", medium: "Medium", high: "High" };
+function isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function thinkingChoices(kind) {
+  switch (kind) {
+    case "openai":
+    case "openai-compatible":
+    case "ollama":
+      return ["off", ...TIERS].map((level) => ({ level, label: LABELS[level] }));
+    case "lmstudio":
+      return [{ level: "off", label: "Off" }, { level: "medium", label: "On" }];
+    case "anthropic":
+      return TIERS.map((level) => ({ level, label: LABELS[level] }));
+    // `vscode.lm` takes no thinking fields, so the dial hides.
+    case "vscode-lm":
+    default:
+      return [];
+  }
+}
+function nearestThinkingLevel(kind, level) {
+  const choices = thinkingChoices(kind);
+  if (!level || choices.length === 0) {
+    return null;
+  }
+  if (choices.some((c) => c.level === level)) {
+    return level;
+  }
+  return level === "off" ? choices[0].level : (choices.find((c) => c.level !== "off") ?? choices[0]).level;
+}
+var SHORT_EDIT_JOBS = /* @__PURE__ */ new Set(["rewrite", "translate", "title", "frontmatter"]);
+function taskThinkingDefault(job) {
+  return job && SHORT_EDIT_JOBS.has(job) ? "off" : null;
+}
+function resolveThinkingLevel(kind, explicit, configured, job, opts = {}) {
+  if (explicit) {
+    return { level: explicit, auto: false };
+  }
+  if (configured) {
+    return { level: null, auto: false };
+  }
+  if (kind === "openai" && opts.modelId !== void 0 && !isOpenAiReasoningModel(opts.modelId, "openai")) {
+    return { level: null, auto: false };
+  }
+  const level = nearestThinkingLevel(kind, taskThinkingDefault(job));
+  return { level, auto: level !== null };
+}
+function thinkingOverrides(kind, level, opts = {}) {
+  if (!thinkingChoices(kind).some((c) => c.level === level)) {
+    return {};
+  }
+  switch (kind) {
+    case "anthropic":
+      return { thinking: { type: "adaptive" }, output_config: { effort: level } };
+    case "openai-compatible":
+      if (level === "off" && opts.local) {
+        return { chat_template_kwargs: { enable_thinking: false } };
+      }
+      return { reasoning_effort: level === "off" ? "none" : level };
+    default:
+      return { reasoning_effort: level === "off" ? "none" : level };
+  }
+}
+function thinkingLevelFrom(kind, overrides) {
+  if (!overrides || thinkingChoices(kind).length === 0) {
+    return null;
+  }
+  if (kind === "anthropic") {
+    const effort2 = isObject3(overrides.output_config) ? overrides.output_config.effort : void 0;
+    return typeof effort2 === "string" && TIERS.includes(effort2) ? effort2 : null;
+  }
+  const kwargs = isObject3(overrides.chat_template_kwargs) ? overrides.chat_template_kwargs : void 0;
+  if (kwargs?.enable_thinking === false) {
+    return "off";
+  }
+  const effort = overrides.reasoning_effort;
+  if (effort === "none") {
+    return "off";
+  }
+  if (typeof effort !== "string" || !TIERS.includes(effort)) {
+    return null;
+  }
+  return kind === "lmstudio" ? "medium" : effort;
+}
+function stripThinking(kind, overrides) {
+  const out = { ...overrides };
+  const dropNested = (key, inner) => {
+    const current = out[key];
+    if (!isObject3(current)) {
+      return;
+    }
+    const rest = { ...current };
+    delete rest[inner];
+    if (Object.keys(rest).length === 0) {
+      delete out[key];
+    } else {
+      out[key] = rest;
+    }
+  };
+  if (kind === "anthropic") {
+    delete out.thinking;
+    dropNested("output_config", "effort");
+  } else {
+    delete out.reasoning_effort;
+    dropNested("chat_template_kwargs", "enable_thinking");
+  }
+  return out;
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    const current = out[key];
+    out[key] = isObject3(current) && isObject3(value) ? deepMerge(current, value) : value;
+  }
+  return out;
+}
+function withThinkingLevel(kind, overrides, level, opts = {}) {
+  const base = stripThinking(kind, overrides ?? {});
+  const next = level ? deepMerge(base, thinkingOverrides(kind, level, opts)) : base;
+  return Object.keys(next).length > 0 ? next : void 0;
+}
+var THINKING_HEADROOM_TOKENS = { off: 0, low: 2048, medium: 4096, high: 8192 };
+var THINKING_DEFAULT_HEADROOM_TOKENS = THINKING_HEADROOM_TOKENS.medium;
+var THINKING_MAX_TOKENS_CAP = 12288;
+function thinkingMaxTokens(answerTokens, level, opts = {}) {
+  const headroom = level ? THINKING_HEADROOM_TOKENS[level] : THINKING_DEFAULT_HEADROOM_TOKENS;
+  if (headroom <= 0) {
+    return answerTokens;
+  }
+  let limit = THINKING_MAX_TOKENS_CAP;
+  if (opts.contextTokens && opts.contextTokens > 0) {
+    limit = Math.min(limit, opts.contextTokens - Math.ceil(opts.promptTokens ?? 0) - 256);
+  }
+  return Math.max(answerTokens, Math.min(answerTokens + headroom, limit));
+}
+
+// src/ai/prompts/rewrite.ts
+var AI_AUDIENCES = [
+  {
+    id: "general",
+    label: "General audience",
+    instruction: "Rewrite it for a general audience: plain words, short sentences, jargon explained or avoided. Keep the meaning and every fact, name and link."
+  },
+  {
+    id: "expert",
+    label: "Expert",
+    instruction: "Rewrite it for expert readers: precise terminology, no basic explanations, dense and direct. Keep the meaning and every fact, name and link."
+  },
+  {
+    id: "plain",
+    label: "Plain language",
+    instruction: "Rewrite it in plain language: everyday words, short sentences, active voice, no jargon or idioms. Keep the meaning and every fact, name and link."
+  },
+  {
+    id: "grade8",
+    label: "8th grade",
+    instruction: "Rewrite it at an 8th grade reading level: common words, short sentences, one idea at a time. Keep the meaning and every fact, name and link."
+  },
+  {
+    id: "esl",
+    label: "English learners (ESL)",
+    instruction: "Rewrite it for readers who are learning English: simple vocabulary, short direct sentences, literal wording, no idioms or phrasal verbs. Keep the meaning and every fact, name and link."
+  }
+];
+function getAiAudience(id) {
+  return AI_AUDIENCES.find((a) => a.id === id);
+}
+var AI_REWRITE_VARIANTS = [
+  {
+    id: "shorter",
+    label: "Shorter",
+    instruction: "Make it shorter and tighter. Keep the meaning and every fact, name and link; cut repetition and filler.",
+    group: "length",
+    output: "replace"
+  },
+  {
+    id: "longer",
+    label: "Longer",
+    title: "Longer: the same points, said at more length",
+    instruction: "Make it longer: add detail, examples or explanation that fit the surrounding text. Do not invent facts, numbers, names or links.",
+    group: "length",
+    output: "replace"
+  },
+  {
+    id: "expand",
+    label: "Add detail",
+    title: "Add detail (facts and examples)",
+    instruction: "Expand it: develop each point with the reasoning, detail or an example that the surrounding text supports, so it reads as a fuller passage. Do not invent facts, numbers, names or links.",
+    group: "length",
+    output: "replace"
+  },
+  {
+    id: "simpler",
+    label: "Simpler",
+    instruction: "Make it simpler: shorter sentences, everyday words, one idea at a time. Keep the meaning and every fact, name and link.",
+    group: "tone",
+    output: "replace"
+  },
+  {
+    id: "fixFlow",
+    label: "Fix flow",
+    instruction: "Fix the flow: correct grammar, spelling and punctuation, and smooth awkward sentences and transitions. Keep the length, meaning and tone close to the original.",
+    group: "tone",
+    output: "replace"
+  },
+  {
+    id: "formal",
+    label: "More formal",
+    instruction: "Make the tone more formal and professional: no contractions or slang, precise wording. Keep the meaning, every fact and the length close to the original.",
+    group: "tone",
+    output: "replace"
+  },
+  {
+    id: "casual",
+    label: "More casual",
+    instruction: "Make the tone more casual and conversational: contractions and everyday phrasing. Keep the meaning, every fact and the length close to the original.",
+    group: "tone",
+    output: "replace"
+  },
+  {
+    id: "readingLevel",
+    label: "Reading level\u2026",
+    instruction: "{audience}",
+    group: "audience",
+    output: "replace",
+    param: "audience"
+  },
+  {
+    id: "translate",
+    label: "Translate\u2026",
+    instruction: "Translate the passage into {language}.",
+    group: "translate",
+    output: "replace",
+    param: "language"
+  },
+  {
+    id: "explain",
+    label: "Explain",
+    instruction: "Explain what the passage says and means in plain words, as a short note for the reader. Do not repeat the passage.",
+    group: "explain",
+    output: "readOnly"
+  },
+  { id: "custom", label: "Custom prompt\u2026", instruction: "", group: "custom", output: "replace" }
+];
+function getAiRewriteVariant(id) {
+  return AI_REWRITE_VARIANTS.find((v) => v.id === id);
+}
+var REWRITE_CONTEXT_CHARS = 1600;
+var REWRITE_INSTRUCTION_MAX_CHARS = 1e3;
+var REWRITE_LANGUAGE_MAX_CHARS = 60;
+var REWRITE_SYSTEM_PROMPT = [
+  "You are a writing assistant inside a Markdown editor. You rewrite the passage the user selected, following one instruction.",
+  "",
+  "Rules:",
+  "- Reply with the rewritten passage only. No preamble, no explanation, no quotation marks and no code fence around it.",
+  "- Keep it Markdown, and keep the structure of the passage: headings stay headings, list items stay list items with the same markers and indentation, tables stay tables, quotes stay quotes. A passage that is part of a sentence stays part of a sentence.",
+  "- Keep every link and image with its exact URL, inline code and code blocks character for character, and inline formatting (bold, italic, strikethrough, ==highlight==, footnote references, [[wikilinks]], #tags, math) on the words it belongs to.",
+  "- Write in the language and voice of the passage.",
+  "- The text before and after the passage is context only. Do not repeat it and do not continue it.",
+  "- If the instruction asks for anything other than a version of the passage, still reply with a version of the passage only."
+].join("\n");
+var TRANSLATE_SYSTEM_ADDENDUM = [
+  'This is a translation. The "write in the language and voice of the passage" rule above does not apply: write in the language named in the instruction.',
+  "- Translate prose only: paragraph text, list item text, table cell text, heading text, image alt text and link text.",
+  "- Keep verbatim, untranslated: the Markdown syntax itself (heading marks, list markers and indentation, table pipes and separator rows, quote marks), link and image URLs, inline code and fenced code blocks (including their language tag), [[wikilinks]], #tags, math, footnote markers such as [^1], HTML tags and frontmatter keys.",
+  "- Keep the line structure: the same number of lines, blocks and list items in the same order, with blank lines where the passage has them.",
+  "- Keep names of people, products and places as they are unless they have a well established translation."
+].join("\n");
+var 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.';
+var 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.";
+function escapeClosingTag(text, tag) {
+  return text.split(`</${tag}>`).join(`<\\/${tag}>`);
+}
+function trimRewriteContext(text, side, max = REWRITE_CONTEXT_CHARS) {
+  if (text.length <= max) {
+    return text;
+  }
+  if (side === "before") {
+    const cut2 = text.slice(text.length - max);
+    const nl2 = cut2.indexOf("\n");
+    return nl2 >= 0 && nl2 < max / 2 ? cut2.slice(nl2 + 1) : cut2;
+  }
+  const cut = text.slice(0, max);
+  const nl = cut.lastIndexOf("\n");
+  return nl > max / 2 ? cut.slice(0, nl) : cut;
+}
+function normalizeRewriteLanguage(language) {
+  return (language ?? "").replace(/[<>\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, REWRITE_LANGUAGE_MAX_CHARS);
+}
+function rewriteInstruction(input) {
+  const fallback = getAiRewriteVariant("fixFlow")?.instruction ?? "";
+  if (input.variant === "custom") {
+    const own = (input.instruction ?? "").trim().slice(0, REWRITE_INSTRUCTION_MAX_CHARS);
+    return own || fallback;
+  }
+  const def = getAiRewriteVariant(input.variant);
+  if (!def) {
+    return "";
+  }
+  if (def.param === "language") {
+    const language = normalizeRewriteLanguage(input.params?.language);
+    return language ? def.instruction.replace("{language}", () => language) : fallback;
+  }
+  if (def.param === "audience") {
+    const audience = input.params?.audience ? getAiAudience(input.params.audience) : void 0;
+    return audience ? def.instruction.replace("{audience}", () => audience.instruction) : fallback;
+  }
+  return def.instruction;
+}
+function rewriteSystemPrompt(variant, scope = "selection") {
+  if (variant === "translate") {
+    return [REWRITE_SYSTEM_PROMPT, TRANSLATE_SYSTEM_ADDENDUM, ...scope === "document" ? [TRANSLATE_DOCUMENT_NOTE] : []].join("\n\n");
+  }
+  if (variant === "explain") {
+    return `${REWRITE_SYSTEM_PROMPT}
+
+${EXPLAIN_SYSTEM_ADDENDUM}`;
+  }
+  return REWRITE_SYSTEM_PROMPT;
+}
+function buildRewriteMessages(input) {
+  const instruction = rewriteInstruction(input);
+  const scope = input.scope === "document" && input.variant === "translate" ? "document" : "selection";
+  const before = scope === "document" ? "" : trimRewriteContext(input.before ?? "", "before").trimEnd();
+  const after = scope === "document" ? "" : trimRewriteContext(input.after ?? "", "after").trimStart();
+  const parts = [];
+  parts.push(input.variant === "custom" ? `Instruction (from the user): <instruction>
+${escapeClosingTag(instruction, "instruction")}
+</instruction>` : `Instruction: ${instruction}`);
+  if (before) {
+    parts.push(`Text before the passage (context only, do not rewrite it):
+<before>
+${escapeClosingTag(before, "before")}
+</before>`);
+  }
+  parts.push(`${input.variant === "explain" ? "Passage to explain" : "Passage to rewrite"}:
+<passage>
+${escapeClosingTag(input.selection, "passage")}
+</passage>`);
+  if (after) {
+    parts.push(`Text after the passage (context only, do not rewrite it):
+<after>
+${escapeClosingTag(after, "after")}
+</after>`);
+  }
+  parts.push(input.variant === "explain" ? "Reply with the explanation only." : "Reply with the rewritten passage only.");
+  return [
+    { role: "system", content: rewriteSystemPrompt(input.variant, scope) },
+    { role: "user", content: parts.join("\n\n") }
+  ];
+}
+var EXPLAIN_MAX_TOKENS = 600;
+var REWRITE_TOKEN_FACTOR = {
+  longer: 3,
+  expand: 3,
+  translate: 3,
+  custom: 3,
+  simpler: 1.8,
+  formal: 1.8,
+  casual: 1.8
+};
+function rewriteMaxTokens(selection, variant) {
+  if (variant === "explain") {
+    return EXPLAIN_MAX_TOKENS;
+  }
+  const approxTokens = Math.ceil(selection.length / 3.5);
+  const factor = REWRITE_TOKEN_FACTOR[variant] ?? 1.6;
+  return Math.max(256, Math.min(4096, Math.ceil(approxTokens * factor) + 64));
+}
+function rewriteVisibleText(raw) {
+  let text = raw.replace(/<think>[\s\S]*?<\/think>\s*/g, "");
+  const open = text.indexOf("<think>");
+  if (open >= 0) {
+    text = text.slice(0, open);
+  }
+  return text.replace(/^\s*<passage>\s*\n?/, "").replace(/\n?\s*<\/passage>\s*$/, "");
+}
+function finalizeRewriteText(raw, selection) {
+  let text = rewriteVisibleText(raw).trim();
+  const fenced = /^```(?:markdown|md|text)?[ \t]*\n([\s\S]*?)\n```$/i.exec(text);
+  if (fenced && !selection.trimStart().startsWith("```")) {
+    text = fenced[1].trim();
+  }
+  const quoted = /^(["“])([\s\S]*)(["”])$/.exec(text);
+  if (quoted && !/^\s*["“]/.test(selection) && !quoted[2].includes(quoted[1])) {
+    text = quoted[2].trim();
+  }
+  if (!text) {
+    return "";
+  }
+  const lead = /^\s*/.exec(selection)?.[0] ?? "";
+  const trail = /\s*$/.exec(selection)?.[0] ?? "";
+  return lead + text + trail;
+}
+
+// src/ai/prompts/explain.ts
+var EXPLAIN_SYSTEM_PROMPT = [
+  "You are a writing assistant inside a Markdown editor. The user selected a passage and wants it explained.",
+  "",
+  "Rules:",
+  "- Reply with the explanation only, as short Markdown prose (a few sentences or a short paragraph, a brief list only when the passage has several distinct points). No preamble, no heading, and no code fence around the whole reply.",
+  "- Explain what the passage says and means, and define any term a reader may not know. Do not repeat or quote the passage back and do not rewrite it.",
+  "- Do not invent facts. If the passage or its context is not enough to explain something, say so in one sentence.",
+  "- Write in the language of the passage.",
+  "- The text before and after the passage and the document title are context only. Do not explain them."
+].join("\n");
+function buildExplainMessages(input) {
+  const before = trimRewriteContext(input.before ?? "", "before").trimEnd();
+  const after = trimRewriteContext(input.after ?? "", "after").trimStart();
+  const title = (input.title ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
+  const parts = [`Instruction: ${getAiRewriteVariant("explain")?.instruction ?? ""}`];
+  if (title) {
+    parts.push(`Document title (context only): ${title}`);
+  }
+  if (before) {
+    parts.push(`Text before the passage (context only, do not explain it):
+<before>
+${escapeClosingTag(before, "before")}
+</before>`);
+  }
+  parts.push(`Passage to explain:
+<passage>
+${escapeClosingTag(input.selection, "passage")}
+</passage>`);
+  if (after) {
+    parts.push(`Text after the passage (context only, do not explain it):
+<after>
+${escapeClosingTag(after, "after")}
+</after>`);
+  }
+  parts.push("Reply with the explanation only.");
+  return [
+    { role: "system", content: EXPLAIN_SYSTEM_PROMPT },
+    { role: "user", content: parts.join("\n\n") }
+  ];
+}
+function explainMaxTokens() {
+  return EXPLAIN_MAX_TOKENS;
+}
+
+// src/ai/prompts/structureCheck.ts
+var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+var HEADING = /^ {0,3}(#{1,6})(?:[ \t]|$)/;
+var LIST_ITEM = /^[ \t]*(?:[-*+]|\d{1,9}[.)])(?:[ \t]|$)/;
+var TABLE_DELIMITER = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+var FOOTNOTE_DEFINITION = /^ {0,3}\[\^[^\]\s]+\]:/;
+var URL_PART = String.raw`<?((?:[^()\s<>]|\([^()\s]*\))+)>?`;
+var LINK_TEXT = String.raw`\[(?:[^\[\]]|\[[^\[\]]*\])*\]`;
+var INLINE_IMAGE = new RegExp(String.raw`!${LINK_TEXT}\(\s*${URL_PART}(?:\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\s*\)`, "g");
+var INLINE_LINK = new RegExp(String.raw`(?<!!)${LINK_TEXT}\(\s*${URL_PART}(?:\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\s*\)`, "g");
+var REFERENCE_DEFINITION = /^ {0,3}\[(?!\^)[^\]]+\]:[ \t]*<?(\S+?)>?(?:[ \t]+["'(].*)?$/gm;
+var AUTOLINK = /<([a-z][a-z0-9+.-]*:[^\s<>]+)>/gi;
+var WIKILINK = /\[\[[^\]\n]+\]\]/g;
+var FOOTNOTE_REFERENCE = /\[\^[^\]\s]+\]/g;
+function splitFences(markdown) {
+  const prose = [];
+  let fenced = 0;
+  let open = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    if (open) {
+      const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
+      if (close && close[1][0] === open.char && close[1].length >= open.length) {
+        open = null;
+      }
+      continue;
+    }
+    const m = FENCE_OPEN.exec(line);
+    if (m && !(m[1][0] === "`" && line.slice(m[0].length).includes("`"))) {
+      open = { char: m[1][0], length: m[1].length };
+      fenced++;
+      continue;
+    }
+    prose.push(line);
+  }
+  return { prose, fenced };
+}
+function stripInlineCode(text) {
+  let count = 0;
+  const out = text.replace(/(`+)(?!`)([\s\S]*?[^`])\1(?!`)/g, () => {
+    count++;
+    return "";
+  });
+  return { text: out, count };
+}
+function tableRowCount(lines) {
+  let rows = 0;
+  for (let i = 1; i < lines.length; i++) {
+    const header = lines[i - 1];
+    if (!lines[i].includes("|") || !lines[i].includes("-") || !TABLE_DELIMITER.test(lines[i]) || !header.includes("|")) {
+      continue;
+    }
+    rows++;
+    let j = i + 1;
+    while (j < lines.length && lines[j].trim() !== "" && lines[j].includes("|")) {
+      rows++;
+      j++;
+    }
+    i = j - 1;
+  }
+  return rows;
+}
+function collect(re, text) {
+  const urls = [];
+  for (const m of text.matchAll(re)) {
+    urls.push(m[1]);
+  }
+  return urls;
+}
+function countMarkdownStructure(markdown) {
+  const { prose, fenced } = splitFences(markdown);
+  const headings = [0, 0, 0, 0, 0, 0];
+  let listItems = 0;
+  for (const line of prose) {
+    const h = HEADING.exec(line);
+    if (h) {
+      headings[h[1].length - 1]++;
+    } else if (LIST_ITEM.test(line)) {
+      listItems++;
+    }
+  }
+  const tableRows = tableRowCount(prose);
+  const code = stripInlineCode(prose.map((l) => l.replace(FOOTNOTE_DEFINITION, "")).join("\n"));
+  const images = collect(INLINE_IMAGE, code.text);
+  const withoutImages = code.text.replace(INLINE_IMAGE, "");
+  const links = [
+    ...collect(INLINE_LINK, withoutImages),
+    ...collect(REFERENCE_DEFINITION, withoutImages),
+    ...collect(AUTOLINK, withoutImages)
+  ];
+  return {
+    headings,
+    fencedCodeBlocks: fenced,
+    inlineCodeSpans: code.count,
+    links,
+    images,
+    listItems,
+    tableRows,
+    wikilinks: (code.text.match(WIKILINK) ?? []).length,
+    footnoteReferences: (code.text.match(FOOTNOTE_REFERENCE) ?? []).length
+  };
+}
+function noun(n, singular, plural = `${singular}s`) {
+  return `${n} ${n === 1 ? singular : plural}`;
+}
+function countMessage(original, result, singular, plural) {
+  return `${noun(original, singular, plural)} in the original, ${result} in the result`;
+}
+function missingUrls(from, against) {
+  const left = /* @__PURE__ */ new Map();
+  for (const u of against) {
+    left.set(u, (left.get(u) ?? 0) + 1);
+  }
+  const missing = [];
+  for (const u of from) {
+    const n = left.get(u) ?? 0;
+    if (n > 0) {
+      left.set(u, n - 1);
+    } else {
+      missing.push(u);
+    }
+  }
+  return missing;
+}
+var URL_LIST_CAP = 3;
+function urlList(urls) {
+  const shown = urls.slice(0, URL_LIST_CAP).join(", ");
+  return urls.length > URL_LIST_CAP ? `${shown} and ${urls.length - URL_LIST_CAP} more` : shown;
+}
+function urlMismatch(kind, original, result) {
+  const missing = missingUrls(original, result);
+  const extra = missingUrls(result, original);
+  if (original.length === result.length && !missing.length) {
+    return null;
+  }
+  const plural = `${kind}s`;
+  let message;
+  if (original.length !== result.length) {
+    message = countMessage(original.length, result.length, kind, plural);
+    if (missing.length) {
+      message += ` (missing: ${urlList(missing)})`;
+    }
+  } else {
+    message = `${noun(original.length, kind, plural)} point somewhere else in the result (missing: ${urlList(missing)}; unexpected: ${urlList(extra)})`;
+  }
+  return { kind, original: original.length, result: result.length, message };
+}
+function checkMarkdownStructure(original, result) {
+  const a = countMarkdownStructure(original);
+  const b = countMarkdownStructure(result);
+  const mismatches = [];
+  const count = (kind, x, y, singular, plural) => {
+    if (x !== y) {
+      mismatches.push({ kind, original: x, result: y, message: countMessage(x, y, singular, plural) });
+    }
+  };
+  a.headings.forEach((n, i) => count("heading", n, b.headings[i], `level ${i + 1} heading`));
+  count("fencedCodeBlock", a.fencedCodeBlocks, b.fencedCodeBlocks, "fenced code block");
+  count("inlineCode", a.inlineCodeSpans, b.inlineCodeSpans, "inline code span");
+  for (const m of [urlMismatch("link", a.links, b.links), urlMismatch("image", a.images, b.images)]) {
+    if (m) {
+      mismatches.push(m);
+    }
+  }
+  count("listItem", a.listItems, b.listItems, "list item");
+  count("tableRow", a.tableRows, b.tableRows, "table row");
+  count("wikilink", a.wikilinks, b.wikilinks, "wikilink");
+  count("footnote", a.footnoteReferences, b.footnoteReferences, "footnote reference");
+  return { ok: mismatches.length === 0, mismatches, messages: mismatches.map((m) => m.message) };
+}
+
+// src/ai/json.ts
+function stripReasoning(raw) {
+  let text = raw.replace(/<think>[\s\S]*?<\/think>/gi, "");
+  const open = text.search(/<think>/i);
+  if (open >= 0) {
+    text = text.slice(0, open);
+  }
+  return text.trim();
+}
+function fencedBodies(text) {
+  const out = [];
+  const re = /```[A-Za-z0-9_-]*[ \t]*\r?\n([\s\S]*?)(?:\r?\n```|$)/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    out.push(m[1]);
+    if (m[0].length === 0) {
+      re.lastIndex++;
+    }
+  }
+  return out;
+}
+function balancedSpan(text, start) {
+  const stack = [];
+  let quote = null;
+  for (let i = start; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      if (c === "\\") {
+        i++;
+      } else if (c === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+    } else if (c === "{") {
+      stack.push("}");
+    } else if (c === "[") {
+      stack.push("]");
+    } else if (c === "}" || c === "]") {
+      if (stack.pop() !== c) {
+        return null;
+      }
+      if (stack.length === 0) {
+        return { end: i + 1 };
+      }
+    }
+  }
+  return null;
+}
+function repairJson(src) {
+  let out = "";
+  let i = 0;
+  let prev = "";
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"' || c === "'") {
+      const q = c;
+      let body = "";
+      i++;
+      while (i < src.length && src[i] !== q) {
+        const ch = src[i];
+        if (ch === "\\" && i + 1 < src.length) {
+          const next = src[i + 1];
+          body += next === "'" ? "'" : ch + next;
+          i += 2;
+          continue;
+        }
+        if (ch === "\n") {
+          body += "\\n";
+        } else if (ch === "\r") {
+          body += "\\r";
+        } else if (ch === "	") {
+          body += "\\t";
+        } else if (ch === '"') {
+          body += '\\"';
+        } else {
+          body += ch;
+        }
+        i++;
+      }
+      i++;
+      out += `"${body}"`;
+      prev = '"';
+      continue;
+    }
+    if (c === ",") {
+      let j = i + 1;
+      while (j < src.length && /\s/.test(src[j])) {
+        j++;
+      }
+      if (src[j] === "}" || src[j] === "]") {
+        i++;
+        continue;
+      }
+    }
+    if ((prev === "{" || prev === ",") && /[A-Za-z_$]/.test(c)) {
+      const m = /^([A-Za-z_$][\w$-]*)(\s*):/.exec(src.slice(i));
+      if (m) {
+        out += `"${m[1]}"${m[2]}:`;
+        i += m[0].length;
+        prev = ":";
+        continue;
+      }
+    }
+    out += c;
+    if (!/\s/.test(c)) {
+      prev = c;
+    }
+    i++;
+  }
+  return out;
+}
+function tryParse(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+var MAX_STARTS = 24;
+function parseLenientJson(raw) {
+  const text = stripReasoning(typeof raw === "string" ? raw : "");
+  if (!text) {
+    return { ok: false, error: "The reply was empty." };
+  }
+  let firstError = "";
+  let sawStart = false;
+  let truncated = false;
+  for (const source of [...fencedBodies(text), text]) {
+    let from = 0;
+    let attempts = 0;
+    while (attempts < MAX_STARTS) {
+      const rel = source.slice(from).search(/[{[]/);
+      if (rel < 0) {
+        break;
+      }
+      const start = from + rel;
+      sawStart = true;
+      attempts++;
+      const span = balancedSpan(source, start);
+      if (!span) {
+        truncated = true;
+        break;
+      }
+      const slice = source.slice(start, span.end);
+      const direct = tryParse(slice);
+      if (direct.ok) {
+        return direct;
+      }
+      const fixed = tryParse(repairJson(slice));
+      if (fixed.ok) {
+        return fixed;
+      }
+      if (!firstError && !direct.ok) {
+        firstError = direct.error;
+      }
+      from = span.end;
+    }
+  }
+  if (!sawStart) {
+    return { ok: false, error: "No JSON object found in the reply." };
+  }
+  if (firstError) {
+    return { ok: false, error: `Invalid JSON: ${firstError}` };
+  }
+  return { ok: false, error: truncated ? "The JSON was cut off before it closed." : "No JSON object found in the reply." };
+}
+var REPAIR_ECHO_CHARS = 4e3;
+function jsonRepairMessages(previousRaw, error) {
+  const previous = stripReasoning(previousRaw).slice(0, REPAIR_ECHO_CHARS);
+  return [
+    { role: "assistant", content: previous || "(empty reply)" },
+    { role: "user", content: `Your previous reply was not valid JSON (${error}). Reply with the JSON object only.` }
+  ];
+}
+function JSON_SHAPE_HINT(example) {
+  const shape = typeof example === "string" ? example : JSON.stringify(example);
+  return `Reply with a JSON object only, in exactly this shape and with no other text, no code fence and no comments: ${shape}`;
+}
+
+// src/ai/documentBudget.ts
+var CHARS_PER_TOKEN = 3.5;
+var FENCE_OPEN2 = /^ {0,3}(`{3,}|~{3,})/;
+var HEADING2 = /^ {0,3}(#{1,6})[ \t]+(.*?)[ \t]*$/;
+var FRONTMATTER = /^---[ \t]*\r?\n[\s\S]*?\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/;
+function frontmatterEnd(markdown) {
+  const m = FRONTMATTER.exec(markdown);
+  return m ? m[0].length : 0;
+}
+function splitLines(markdown, from) {
+  const lines = [];
+  let pos = from;
+  while (pos < markdown.length) {
+    const nl = markdown.indexOf("\n", pos);
+    const end = nl < 0 ? markdown.length : nl;
+    lines.push({ text: markdown.slice(pos, end).replace(/\r$/, ""), start: pos });
+    pos = nl < 0 ? markdown.length : nl + 1;
+  }
+  return lines;
+}
+function fenceMask(lines) {
+  const mask = [];
+  let fence4 = null;
+  for (const line of lines) {
+    if (!fence4) {
+      const m = FENCE_OPEN2.exec(line.text);
+      if (m) {
+        fence4 = { char: m[1][0], len: m[1].length };
+        mask.push(true);
+      } else {
+        mask.push(false);
+      }
+      continue;
+    }
+    mask.push(true);
+    const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line.text);
+    if (close && close[1][0] === fence4.char && close[1].length >= fence4.len) {
+      fence4 = null;
+    }
+  }
+  return mask;
+}
+function headingsOutline(markdown) {
+  const lines = splitLines(markdown, frontmatterEnd(markdown));
+  const mask = fenceMask(lines);
+  const out = [];
+  lines.forEach((line, i) => {
+    if (mask[i]) {
+      return;
+    }
+    const m = HEADING2.exec(line.text);
+    if (!m) {
+      return;
+    }
+    const text = m[2].replace(/[ \t]+#+$/, "").trim();
+    if (text) {
+      out.push({ level: m[1].length, text });
+    }
+  });
+  return out;
+}
+function sectionStarts(markdown, lines, mask) {
+  const starts = [0];
+  const bodyStart = lines.length > 0 ? lines[0].start : markdown.length;
+  lines.forEach((line, i) => {
+    if (mask[i] || !HEADING2.test(line.text)) {
+      return;
+    }
+    if (markdown.slice(bodyStart, line.start).trim() === "") {
+      return;
+    }
+    starts.push(line.start);
+  });
+  return starts;
+}
+function blockStarts(lines, mask) {
+  const starts = [];
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].text.trim() === "") {
+      continue;
+    }
+    if (lines[i - 1].text.trim() === "" && !mask[i - 1]) {
+      starts.push(lines[i].start);
+    }
+  }
+  return starts;
+}
+function budgetDocument(markdown, opts) {
+  const total = markdown.length;
+  const budgetTokens = opts.contextTokens - opts.outputTokens - opts.reserveTokens;
+  const budgetChars = Math.max(0, Math.floor(budgetTokens * CHARS_PER_TOKEN));
+  const fmEnd = frontmatterEnd(markdown);
+  const lines = splitLines(markdown, fmEnd);
+  const mask = fenceMask(lines);
+  const starts = sectionStarts(markdown, lines, mask);
+  const sectionsTotal = starts.length;
+  if (total <= budgetChars || total === 0) {
+    return { text: markdown, coverage: 1, truncated: false, sectionsIncluded: sectionsTotal, sectionsTotal };
+  }
+  let cut = 0;
+  let sectionsIncluded = 0;
+  for (let i = 1; i < starts.length; i++) {
+    if (starts[i] > budgetChars) {
+      break;
+    }
+    cut = starts[i];
+    sectionsIncluded = i;
+  }
+  if (cut === 0) {
+    const firstEnd = starts.length > 1 ? starts[1] : total;
+    const blocks = blockStarts(lines, mask).filter((s) => s < firstEnd);
+    cut = blocks.length > 0 ? blocks[0] : firstEnd;
+    for (const s of blocks) {
+      if (s > budgetChars) {
+        break;
+      }
+      cut = Math.max(cut, s);
+    }
+    sectionsIncluded = 1;
+  }
+  if (cut >= total) {
+    return { text: markdown, coverage: 1, truncated: false, sectionsIncluded: sectionsTotal, sectionsTotal };
+  }
+  const text = markdown.slice(0, cut).trimEnd();
+  return {
+    text,
+    coverage: Math.min(0.999, Math.max(1e-3, cut / total)),
+    truncated: true,
+    sectionsIncluded,
+    sectionsTotal
+  };
+}
+
+// src/ai/prompts/summary.ts
+var SUMMARY_SHORT_DOCUMENT_CHARS = 1200;
+var COMMON_RULES = [
+  "Reply with Markdown only. No preamble, no closing remarks, no code fence around the answer and no title line.",
+  "Use only what the document says. Do not invent facts, names or numbers.",
+  "Write in the language of the document."
+];
+var SUMMARY_SYSTEM_PROMPT = [
+  "You are a writing assistant inside a Markdown editor. You write a short TL;DR of the document the user gives you.",
+  "",
+  "Rules:",
+  '- Write 3 to 6 bullet points, one line each, most important first. Each bullet is a list item starting with "- ".',
+  '- Plain wording that someone who has not read the document can follow. No heading, no "Summary" label.',
+  ...COMMON_RULES.map((r) => `- ${r}`)
+].join("\n");
+var OUTLINE_SYSTEM_PROMPT = [
+  "You are a writing assistant inside a Markdown editor. You write an outline of the document the user gives you.",
+  "",
+  "Rules:",
+  '- Reply with a nested Markdown list: top-level items are the main sections, indented items (two spaces per level, "- " markers) are their subsections or key points. At most three levels.',
+  "- If the document has headings, follow them in order and keep their wording. If it has none, propose short headings that fit its parts.",
+  "- Each item is a few words, not a sentence. No heading syntax (#) and no numbering.",
+  ...COMMON_RULES.map((r) => `- ${r}`)
+].join("\n");
+function fence(text, tag) {
+  return text.split(`</${tag}>`).join(`<\\/${tag}>`);
+}
+function coveragePercent(coverage) {
+  return Math.max(1, Math.min(99, Math.round(coverage * 100)));
+}
+function buildSummaryMessages(input) {
+  const parts = [];
+  if (input.kind === "tldr") {
+    parts.push(input.document.length < SUMMARY_SHORT_DOCUMENT_CHARS ? "This document is short: write one paragraph of two to four sentences instead of bullet points." : "Write the TL;DR as 3 to 6 bullet points.");
+  } else {
+    parts.push("Write the outline.");
+  }
+  if (input.coverage < 1) {
+    parts.push(`Only the first ${coveragePercent(input.coverage)}% of the document is included below; it was cut to fit. Cover only what is shown and do not guess at the rest.`);
+  }
+  parts.push(`Document:
+<document>
+${fence(input.document, "document")}
+</document>`);
+  parts.push(input.kind === "tldr" ? "Reply with the TL;DR only." : "Reply with the outline list only.");
+  return [
+    { role: "system", content: input.kind === "tldr" ? SUMMARY_SYSTEM_PROMPT : OUTLINE_SYSTEM_PROMPT },
+    { role: "user", content: parts.join("\n\n") }
+  ];
+}
+function summaryMaxTokens(kind, inputChars) {
+  const approxTokens = Math.ceil(inputChars / 3.5);
+  return kind === "tldr" ? Math.max(256, Math.min(700, Math.ceil(approxTokens * 0.2) + 128)) : Math.max(384, Math.min(1200, Math.ceil(approxTokens * 0.3) + 160));
+}
+function summaryVisibleText(raw) {
+  return rewriteVisibleText(raw);
+}
+function tidy(raw, kind) {
+  let text = rewriteVisibleText(raw).trim();
+  let lines = text.split("\n");
+  const dropLeadIn = () => {
+    if (lines.length > 1 && /^(here('s| is| are)|sure|certainly|of course)\b[^\n]*:\s*$/i.test(lines[0].trim())) {
+      lines.shift();
+      while (lines.length > 0 && lines[0].trim() === "") {
+        lines.shift();
+      }
+    }
+  };
+  dropLeadIn();
+  text = lines.join("\n").trim();
+  const fenced = /^```(?:markdown|md|text)?[ \t]*\n([\s\S]*?)\n```$/i.exec(text);
+  if (fenced) {
+    text = fenced[1].trim();
+  }
+  lines = text.split("\n");
+  dropLeadIn();
+  if (kind === "tldr" && lines.length > 1 && /^(?:#{1,6}\s*)?(?:\*\*|__)?\s*(?:summary|tl;?dr)\s*:?\s*(?:\*\*|__)?\s*:?\s*$/i.test(lines[0].trim())) {
+    lines.shift();
+  }
+  return lines.join("\n").trim();
+}
+function dropCutFragment(text) {
+  let t = text.trimEnd();
+  if (!t) {
+    return "";
+  }
+  if (!/[.!?;:)\]"'”’`*_]$/.test(t)) {
+    t = t.replace(/\S+$/, "").trimEnd();
+  }
+  t = t.replace(/(^|\n)[ \t]*(?:[-*+]|\d+[.)]|>|#{1,6})?[ \t]*$/, "").trimEnd();
+  if (!t) {
+    return "";
+  }
+  return /[\p{L}\p{N}]$/u.test(t) ? `${t}\u2026` : `${t} \u2026`;
+}
+function summaryPreviewText(raw, kind, cutOff = false) {
+  return cutOff ? dropCutFragment(tidy(raw, kind)) : tidy(raw, kind);
+}
+function finalizeSummary(raw, kind, coverage = 1, cutOff = false) {
+  const body = cutOff ? dropCutFragment(tidy(raw, kind)) : tidy(raw, kind);
+  if (!body) {
+    return "";
+  }
+  const note = coverage < 1 ? `Covers the first ${coveragePercent(coverage)}% of the document.` : "";
+  if (kind === "outline") {
+    return note ? `${body}
+
+${note}` : body;
+  }
+  const inner = ["**Summary**", "", body, ...note ? ["", note] : []].join("\n");
+  return ["[!NOTE]", inner].join("\n").split("\n").map((l) => l ? `> ${l}` : ">").join("\n");
+}
+
+// src/ai/prompts/title.ts
+var TITLE_MAX_CHARS = 120;
+var TITLE_OUTLINE_MAX_ITEMS = 60;
+var TITLE_SYSTEM_PROMPT = [
+  "You are a writing assistant inside a Markdown editor. You suggest titles for the document the user gives you.",
+  "",
+  "Rules:",
+  "- Each title is specific to this document, in plain wording, in Title Case or sentence case to match the document, under 80 characters, with no trailing period and no quotation marks.",
+  "- Make the titles different from each other in angle (descriptive, benefit-led, short).",
+  "- Write in the language of the document.",
+  "- Reply with the JSON object only."
+].join("\n");
+function fence2(text, tag) {
+  return text.split(`</${tag}>`).join(`<\\/${tag}>`);
+}
+function renderHeadingOutline(outline, max = TITLE_OUTLINE_MAX_ITEMS) {
+  const shown = outline.slice(0, max).map((h) => `${"  ".repeat(Math.max(0, h.level - 1))}- ${h.text}`);
+  if (outline.length > max) {
+    shown.push(`(${outline.length - max} more headings)`);
+  }
+  return shown.join("\n");
+}
+function buildTitleMessages(input) {
+  const count = Math.max(1, Math.min(8, input.count ?? 3));
+  const placeholders = Array.from({ length: count }, (_, i) => `title ${i + 1}`);
+  const parts = [`Suggest ${count} titles for this document.`];
+  const existing = (input.existingTitle ?? "").trim();
+  if (existing) {
+    parts.push(`The current title is "${existing.replace(/"/g, "'")}". Do not repeat it.`);
+  }
+  if (input.outline.length > 0) {
+    parts.push(`Headings of the whole document:
+<headings>
+${fence2(renderHeadingOutline(input.outline), "headings")}
+</headings>`);
+  }
+  parts.push(`Document:
+<document>
+${fence2(input.document, "document")}
+</document>`);
+  parts.push(JSON_SHAPE_HINT({ titles: placeholders }));
+  return [
+    { role: "system", content: TITLE_SYSTEM_PROMPT },
+    { role: "user", content: parts.join("\n\n") }
+  ];
+}
+function titleMaxTokens(count = 3) {
+  return 128 + 48 * Math.max(1, count);
+}
+function cleanTitle(value) {
+  let t = value.replace(/\s+/g, " ").trim();
+  t = t.replace(/^["“'‘]+|["”'’]+$/g, "").trim();
+  t = t.replace(/^#{1,6}\s+/, "").replace(/[.。]+$/, "").trim();
+  if (t.length > TITLE_MAX_CHARS) {
+    t = t.slice(0, TITLE_MAX_CHARS).trimEnd();
+  }
+  return t;
+}
+var sameTitle = (a, b) => a.toLowerCase() === b.toLowerCase();
+function parseTitles(raw, existingTitle) {
+  const parsed = parseLenientJson(raw);
+  if (!parsed.ok) {
+    return { ok: false, error: parsed.error };
+  }
+  const v = parsed.value;
+  let list;
+  if (Array.isArray(v)) {
+    list = v;
+  } else if (v && typeof v === "object") {
+    const o = v;
+    list = o.titles ?? (typeof o.title === "string" ? [o.title] : void 0);
+  }
+  if (!Array.isArray(list)) {
+    return { ok: false, error: 'The JSON has no "titles" array.' };
+  }
+  const existing = (existingTitle ?? "").trim();
+  const titles = [];
+  for (const item of list) {
+    if (typeof item !== "string") {
+      continue;
+    }
+    const t = cleanTitle(item);
+    if (!t || existing && sameTitle(t, existing) || titles.some((x) => sameTitle(x, t))) {
+      continue;
+    }
+    titles.push(t);
+  }
+  if (titles.length === 0) {
+    return { ok: false, error: 'The "titles" array has no usable title.' };
+  }
+  return { ok: true, titles };
+}
+
+// src/ai/prompts/properties.ts
+var PROPERTY_MAX_TAGS = 8;
+var PROPERTY_DESCRIPTION_MAX_CHARS = 200;
+var PROPERTY_TITLE_MAX_CHARS = 120;
+var PROPERTY_VOCABULARY_MAX = 80;
+var PROPERTIES_SYSTEM_PROMPT = [
+  "You are a writing assistant inside a Markdown editor. You suggest frontmatter properties for the document the user gives you: a title, a description and tags.",
+  "",
+  "Rules:",
+  "- title: specific to the document, under 80 characters, no trailing period and no quotation marks.",
+  "- description: one or two plain sentences under 160 characters that say what the document is about. No marketing wording.",
+  '- tags: 3 to 6 short topic tags, lowercase, words joined by hyphens, no "#" and no spaces. Nested tags use a slash, like project/active.',
+  "- Prefer tags from the list of existing tags when they fit. Add a new tag only when none of them does.",
+  "- Do not repeat a tag the document already has.",
+  "- Write in the language of the document.",
+  "- Reply with the JSON object only."
+].join("\n");
+function fence3(text, tag) {
+  return text.split(`</${tag}>`).join(`<\\/${tag}>`);
+}
+function entryValue(value) {
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+function existingTagsOf(existing) {
+  const out = [];
+  for (const entry of existing) {
+    if (!/^tags?$/i.test(entry.key)) {
+      continue;
+    }
+    const parts = Array.isArray(entry.value) ? entry.value : entry.value.split(/[,\s]+/);
+    for (const p of parts) {
+      const t = normalizeTag(p);
+      if (t && !out.includes(t)) {
+        out.push(t);
+      }
+    }
+  }
+  return out;
+}
+function buildPropertiesMessages(input) {
+  const parts = ["Suggest a title, a description and tags for this document."];
+  const props = input.existing.filter((e) => entryValue(e.value).trim() !== "");
+  if (props.length > 0) {
+    parts.push(`Properties it already has:
+<properties>
+${fence3(props.map((e) => `${e.key}: ${entryValue(e.value)}`).join("\n"), "properties")}
+</properties>`);
+  }
+  const vocabulary = input.vocabulary.slice(0, PROPERTY_VOCABULARY_MAX);
+  if (vocabulary.length > 0) {
+    parts.push(`Prefer these existing tags when they fit:
+<tags>
+${fence3(vocabulary.join(", "), "tags")}
+</tags>`);
+  }
+  if (input.outline.length > 0) {
+    parts.push(`Headings of the whole document:
+<headings>
+${fence3(renderHeadingOutline(input.outline), "headings")}
+</headings>`);
+  }
+  parts.push(`Document:
+<document>
+${fence3(input.document, "document")}
+</document>`);
+  parts.push(JSON_SHAPE_HINT({ title: "the title", description: "one or two sentences", tags: ["tag-one", "tag-two", "tag-three"] }));
+  return [
+    { role: "system", content: PROPERTIES_SYSTEM_PROMPT },
+    { role: "user", content: parts.join("\n\n") }
+  ];
+}
+function propertiesMaxTokens() {
+  return 384;
+}
+function cleanTag(raw) {
+  const t = normalizeTag(raw.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9_/#-]/g, ""));
+  if (!t) {
+    return null;
+  }
+  const segments = t.split("/").map((s) => s.replace(/^-+|-+$/g, "")).filter(Boolean);
+  const joined = segments.join("/");
+  return /[a-z]/.test(joined) ? joined : null;
+}
+function oneLine(value, max) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  const t = value.replace(/\s+/g, " ").trim().replace(/^["“]+|["”]+$/g, "").trim();
+  return t.length > max ? t.slice(0, max).trimEnd() : t;
+}
+function firstScalar(existing, key) {
+  const entry = existing.find((e) => e.key.toLowerCase() === key);
+  return entry ? entryValue(entry.value).trim() : "";
+}
+function parsePropertySuggestions(raw, existing, vocabulary) {
+  const parsed = parseLenientJson(raw);
+  if (!parsed.ok) {
+    return { ok: false, error: parsed.error };
+  }
+  const v = parsed.value;
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    return { ok: false, error: "The JSON is not an object." };
+  }
+  const o = v;
+  const suggestions = { tags: [] };
+  const title = oneLine(o.title, PROPERTY_TITLE_MAX_CHARS).replace(/[.。]+$/, "");
+  if (title && title.toLowerCase() !== firstScalar(existing, "title").toLowerCase()) {
+    suggestions.title = title;
+  }
+  const description = oneLine(o.description, PROPERTY_DESCRIPTION_MAX_CHARS);
+  if (description && description.toLowerCase() !== firstScalar(existing, "description").toLowerCase()) {
+    suggestions.description = description;
+  }
+  const rawTags = Array.isArray(o.tags) ? o.tags : typeof o.tags === "string" ? o.tags.split(/[,\n]+/) : [];
+  const present = new Set(existingTagsOf(existing));
+  const known = /* @__PURE__ */ new Set();
+  for (const t of vocabulary) {
+    const n = normalizeTag(t);
+    if (n) {
+      known.add(n);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of rawTags) {
+    if (typeof item !== "string") {
+      continue;
+    }
+    const tag = cleanTag(item);
+    if (!tag || present.has(tag) || seen.has(tag)) {
+      continue;
+    }
+    seen.add(tag);
+    suggestions.tags.push({ tag, known: known.has(tag) });
+    if (suggestions.tags.length >= PROPERTY_MAX_TAGS) {
+      break;
+    }
+  }
+  const hadContent = oneLine(o.title, 1) !== "" || oneLine(o.description, 1) !== "" || rawTags.some((t) => typeof t === "string" && cleanTag(t));
+  if (!hadContent) {
+    return { ok: false, error: "The JSON has no usable title, description or tags." };
+  }
+  return { ok: true, suggestions };
+}
+
+// src/ai/privacy.ts
+var AI_CLOUD_PRIVACY = {
+  leaves: "Text you ask about is sent over the internet to the provider and processed on their servers.",
+  terms: "API traffic is covered by the provider's API terms, which differ from its consumer apps. Whether it is retained or used for training is set by those terms and may change; read them before you decide.",
+  local: "A local engine keeps everything on this machine or your network.",
+  keys: "Your API key stays in this app's secure storage on this machine."
+};
+var AI_HOST_PRIVACY = {
+  leaves: "Text you ask about goes through VS Code to GitHub\u2019s Copilot service and is processed on GitHub\u2019s servers, under your Copilot plan.",
+  terms: "Whether it is retained or used for training is set by your plan\u2019s terms, which differ between individual and business plans and may change; read them before you decide.",
+  local: AI_CLOUD_PRIVACY.local,
+  permission: "VS Code also asks for its own permission the first time MikeDown uses Copilot."
+};
+function aiConsentStepNote(hostAsks) {
+  return hostAsks ? "MikeDown asks before a cloud engine's first request in each workspace or folder." : "Once allowed, this app sends requests to cloud engines without asking again.";
+}
+var AI_SENDS_TEXT = {
+  selection: "the selected text and the paragraph before and after it",
+  document: "the whole document, up to what fits the model",
+  documentAndTags: "the document, its frontmatter and the tag names used in this workspace"
+};
+var AI_SENDS_FALLBACK = "the text you ask the AI about";
+function whatIsSent(feature, sends) {
+  const scope = sends ?? (feature ? getAiFeature(feature)?.sends : void 0);
+  return scope ? AI_SENDS_TEXT[scope] : AI_SENDS_FALLBACK;
+}
+function aiProviderPolicyForHost(host, presets = AI_ENGINE_PRESETS) {
+  const h = host?.trim().toLowerCase();
+  if (!h) {
+    return void 0;
+  }
+  return presets.find((p) => p.family === "cloud" && p.policy && hostOfUrl(p.baseUrl) === h)?.policy;
+}
+function aiProviderPolicy(engine, presets = AI_ENGINE_PRESETS) {
+  if (engine.kind && isHostEngineKind(engine.kind)) {
+    return presets.find((p) => p.family === "host" && p.kind === engine.kind && p.policy)?.policy;
+  }
+  return aiProviderPolicyForHost(hostOfUrl(engine.baseUrl), presets);
+}
+var HOST_KIND_SERVICE = { "vscode-lm": "GitHub Copilot" };
+function aiConsentHost(engine) {
+  const service = engine.kind ? HOST_KIND_SERVICE[engine.kind] : void 0;
+  return service ?? hostOfUrl(engine.baseUrl) ?? engine.baseUrl;
+}
+function aiConsentText(input) {
+  const { engineName: name, host, scopeWord, policy } = input;
+  const sends = whatIsSent(input.feature, input.sends);
+  const paragraphs = input.kind && isHostEngineKind(input.kind) ? [
+    `${name === host ? name : `${name} (${host})`} is a cloud service built into VS Code. If you allow it, this request sends ${sends}. It goes through VS Code over the internet and is processed on the service's servers. ${AI_HOST_PRIVACY.permission}`,
+    AI_HOST_PRIVACY.terms
+  ] : [
+    `${name} is a cloud engine at ${host}. If you allow it, this request sends ${sends}. It goes over the internet and is processed on the provider's servers.`,
+    policy?.note ? `${AI_CLOUD_PRIVACY.terms} ${policy.note}` : AI_CLOUD_PRIVACY.terms
+  ];
+  if (policy && input.policyLine) {
+    paragraphs.push(`${policy.label}: ${policy.url}`);
+  }
+  const allow = `Allow for this ${scopeWord}`;
+  paragraphs.push(scopeWord === "session" ? `You can use a local engine instead. ${allow} lasts until you quit MikeDown.` : `You can use a local engine instead. ${allow} is remembered; you can change it in AI settings \u2192 Cloud consents.`);
+  return {
+    title: `Send text to ${name}?`,
+    body: paragraphs.join("\n\n"),
+    allow,
+    allowOnce: "Allow once",
+    deny: "Don't allow",
+    ...policy && !input.policyLine ? { readPolicy: "Read the provider's policy" } : {}
+  };
+}
+var AI_NO_CONSENTS_TEXT = "No cloud engine has been allowed here.";
+var CONSENT_ANSWER_TEXT = {
+  allow: "Allowed",
+  never: "Not allowed",
+  deny: "Not allowed until restart"
+};
+function aiConsentSummary(record, engineName) {
+  const where = record.scope === "folder" ? "this folder" : "this workspace";
+  return `${engineName} \xB7 ${where} \xB7 ${CONSENT_ANSWER_TEXT[record.answer] ?? "Not allowed"}`;
+}
+
+// src/ai/setup.ts
+var GIB = 1024 ** 3;
+var NOMINAL_SLACK = 0.94;
+var AI_LOCAL_MIN_UNIFIED_GB = 16;
+var AI_LOCAL_MIN_MEMORY_GB = 32;
+var AI_LOCAL_MIN_VRAM_GB = 8;
+function formatMemoryGb(bytes) {
+  return `${Math.max(1, Math.round(bytes / GIB))} GB`;
+}
+function atLeastGb(bytes, gb) {
+  return typeof bytes === "number" && bytes >= gb * GIB * NOMINAL_SLACK;
+}
+function nvidiaVram(hw) {
+  return hw.gpu?.vendor === "nvidia" ? hw.gpu.vramBytes : void 0;
+}
+function isLocalCapable(hw) {
+  if (!hw) {
+    return false;
+  }
+  if (hw.appleSilicon && atLeastGb(hw.totalMemoryBytes, AI_LOCAL_MIN_UNIFIED_GB)) {
+    return true;
+  }
+  if (atLeastGb(hw.totalMemoryBytes, AI_LOCAL_MIN_MEMORY_GB)) {
+    return true;
+  }
+  return atLeastGb(nvidiaVram(hw), AI_LOCAL_MIN_VRAM_GB);
+}
+function modelMemoryBytes(hw) {
+  if (hw.appleSilicon) {
+    return hw.totalMemoryBytes;
+  }
+  const vram = nvidiaVram(hw);
+  return typeof vram === "number" && vram > 0 ? vram : hw.totalMemoryBytes;
+}
+function memoryBand(bytes) {
+  if (!atLeastGb(bytes, 24)) {
+    return "small";
+  }
+  return atLeastGb(bytes, 48) ? "large" : "medium";
+}
+var SIZE_SENTENCES = {
+  small: "Models up to about 8B parameters run well.",
+  medium: "Models up to about 30B parameters run well.",
+  large: "Larger models work, well beyond 30B parameters."
+};
+function localSizeHint(hw) {
+  return hw ? SIZE_SENTENCES[memoryBand(modelMemoryBytes(hw))] : "";
+}
+function describeHardware(hw) {
+  if (hw.appleSilicon) {
+    return `Apple Silicon, ${formatMemoryGb(hw.totalMemoryBytes)}`;
+  }
+  const parts = [`${formatMemoryGb(hw.totalMemoryBytes)} of memory`];
+  if (hw.gpu && hw.gpu.vendor !== "apple") {
+    const name = hw.gpu.name?.trim() || (hw.gpu.vendor === "nvidia" ? "NVIDIA GPU" : hw.gpu.vendor === "amd" ? "AMD GPU" : "GPU");
+    parts.push(hw.gpu.vramBytes ? `${name} (${formatMemoryGb(hw.gpu.vramBytes)})` : name);
+  }
+  return parts.join(", ");
+}
+var AI_LOCAL_SMALL_MACHINE = "This machine is on the small side for local models; cloud is the easier path.";
+var AI_LOCAL_ROUGH_GUESS = "A rough guess from memory alone; the graphics card was not checked.";
+function hardwareLine(hw, capable) {
+  if (!hw) {
+    return "";
+  }
+  if (!capable) {
+    return AI_LOCAL_SMALL_MACHINE;
+  }
+  const rough = !hw.appleSilicon && !hw.gpu ? ` ${AI_LOCAL_ROUGH_GUESS}` : "";
+  return `Local is an option on this machine: ${describeHardware(hw)}. ${localSizeHint(hw)}${rough}`;
+}
+function isUsableServer(p) {
+  return p.ok && p.models !== 0;
+}
+function presetName(id) {
+  return AI_ENGINE_PRESETS.find((p) => p.id === id)?.name ?? id;
+}
+function modelsText(n) {
+  return n === void 0 ? "" : ` with ${n} ${n === 1 ? "model" : "models"}`;
+}
+function recommendSetupPath(input) {
+  const hw = input.hardware;
+  const localCapable = isLocalCapable(hw);
+  const base = { localCapable, localHint: localSizeHint(hw), hardwareLine: hardwareLine(hw, localCapable) };
+  const reasons = [];
+  const servers = input.running.map((probe, index) => ({ probe, index })).filter(({ probe }) => isUsableServer(probe)).sort((a, b) => (b.probe.models ?? 0) - (a.probe.models ?? 0) || a.index - b.index);
+  if (servers.length > 0) {
+    const first = servers[0].probe;
+    reasons.push(`${presetName(first.presetId)} is running on this machine${modelsText(first.models)}.`);
+    return { path: "runningLocal", ...base, running: first, reasons };
+  }
+  const idle = input.running.filter((p) => p.ok && p.models === 0);
+  reasons.push(idle.length > 0 ? `${idle.map((p) => presetName(p.presetId)).join(" and ")} answered but lists no models.` : "No local model server is running.");
+  if (input.vscodeLm?.available && input.vscodeLm.models > 0) {
+    reasons.push(`GitHub Copilot offers ${input.vscodeLm.models} ${input.vscodeLm.models === 1 ? "model" : "models"} in VS Code.`);
+    return { path: "vscodeLm", ...base, reasons };
+  }
+  if (input.vscodeLm) {
+    reasons.push("GitHub Copilot offers no model in VS Code.");
+  }
+  if (!hw) {
+    reasons.push("The host did not report this machine\u2019s hardware.");
+  } else {
+    reasons.push(localCapable ? `${describeHardware(hw)} can run local models.` : `${describeHardware(hw)} is below the threshold for local models.`);
+  }
+  return { path: "cloud", ...base, reasons };
+}
+function vscodeLmAvailability(probes) {
+  const probe = probes?.find((p) => p.kind === "vscode-lm");
+  return { available: !!probe?.ok && probe.models > 0, models: probe?.ok ? probe.models : 0 };
+}
+function modelParamsBillions(id) {
+  const s = id.toLowerCase();
+  const moe = /(?:^|[^a-z0-9.])(\d+)x(\d+(?:\.\d+)?)b(?![a-z0-9])/.exec(s);
+  if (moe) {
+    return Number(moe[1]) * Number(moe[2]);
+  }
+  const m = /(?:^|[^a-z0-9.])(\d+(?:\.\d+)?)([bm])(?![a-z0-9])/.exec(s);
+  if (!m) {
+    return null;
+  }
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) {
+    return null;
+  }
+  return m[2] === "m" ? n / 1e3 : n;
+}
+var TIGHT_FACTOR = 1.75;
+function fitsBillions(hw) {
+  const memoryBytes = modelMemoryBytes(hw);
+  const gb = memoryBytes / GIB;
+  switch (memoryBand(memoryBytes)) {
+    case "small":
+      return isLocalCapable(hw) ? 8 : Math.min(8, gb / 2);
+    case "medium":
+      return 30;
+    case "large":
+      return gb * 1.1;
+  }
+}
+function modelSizeHint(id, hardware, sizeBytes) {
+  if (!hardware) {
+    return void 0;
+  }
+  if (typeof sizeBytes === "number" && sizeBytes > 0) {
+    return modelSizeHintFromBytes(sizeBytes, hardware);
+  }
+  const params = modelParamsBillions(id);
+  if (params === null) {
+    return void 0;
+  }
+  const fits = fitsBillions(hardware);
+  if (params <= fits) {
+    return "fits";
+  }
+  return params <= fits * TIGHT_FACTOR ? "tight" : "too large";
+}
+var FITS_SHARE = 0.6;
+var TIGHT_SHARE = 0.8;
+function modelSizeHintFromBytes(sizeBytes, hardware) {
+  const memory = modelMemoryBytes(hardware);
+  if (sizeBytes <= memory * FITS_SHARE) {
+    return "fits";
+  }
+  return sizeBytes <= memory * TIGHT_SHARE ? "tight" : "too large";
+}
+function formatModelSize(bytes) {
+  const gb = bytes / GIB;
+  return `${gb >= 10 ? Math.round(gb) : Math.round(gb * 10) / 10} GB`;
+}
+function modelActiveParamsBillions(id) {
+  const m = /(?:^|[^a-z0-9.])a(\d+(?:\.\d+)?)b(?![a-z0-9])/.exec(id.toLowerCase());
+  const n = m ? Number(m[1]) : NaN;
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function modelMoeHint(id, moe) {
+  const active = modelActiveParamsBillions(id);
+  return active !== null || moe ? { activeBillions: active } : null;
+}
+function modelMoeFastHint(id, moe, size) {
+  if (size !== "fits") {
+    return null;
+  }
+  return modelMoeHint(id, moe);
+}
+function localDefaultModel(models) {
+  return models.find((m) => m.chat && !m.missing && m.loaded)?.id ?? null;
+}
+
+export {
+  AI_ENGINE_KINDS,
+  AI_HOST_ENGINE_KINDS,
+  AI_CAPABILITY_FLAGS,
+  DEFAULT_CONTEXT_TOKENS,
+  AI_FALLBACK_MODES,
+  AI_ERROR_CODES,
+  SUMMARIZE_MIN_CONTEXT_TOKENS,
+  AI_TASKS,
+  getAiTask,
+  combineRequirements,
+  missingCapabilities,
+  AI_FEATURES,
+  getAiFeature,
+  resolveAiFeature,
+  ANTHROPIC_MODEL_TABLE,
+  OPENAI_MODEL_TABLE,
+  isOpenAiReasoningModel,
+  openAiOffReasoningEffort,
+  detectCapabilities,
+  completeCapabilities,
+  mergeDiscoveredModels,
+  AI_PRESET_FAMILIES,
+  AI_HOST_PRESET_FAMILY,
+  AI_ENGINE_PRESETS,
+  presetForEngine,
+  AI_LOCAL_DETECT_TIMEOUT_MS,
+  localDetectCandidates,
+  parseOpenAiModelList,
+  parseLmStudioModels,
+  parseOmlxModelStatus,
+  withModelStatus,
+  parseModelSizes,
+  withModelSizes,
+  parseOllamaTags,
+  parseOllamaShow,
+  parseOllamaRunning,
+  parseAnthropicModels,
+  anthropicNextPage,
+  localDetectUrl,
+  countDetectedModels,
+  localDetectTarget,
+  AI_SETTINGS_KEYS,
+  isKnownEngineKind,
+  isHostEngineKind,
+  generateAiId,
+  parseAiSettings,
+  serializeAiSettings,
+  isRouteUsable,
+  resolveRoute,
+  SseParser,
+  createOpenAiStreamReader,
+  createAnthropicStreamReader,
+  createCompletionStreamReader,
+  AI_CHARS_PER_TOKEN,
+  aiResultStats,
+  formatAiSeconds,
+  formatAiTokensPerSecond,
+  aiResultStatsText,
+  aiResultStatsTitle,
+  aiTimingLogParts,
+  ANTHROPIC_API_VERSION,
+  ANTHROPIC_DEFAULT_MAX_TOKENS,
+  JSON_ONLY_INSTRUCTION,
+  engineEndpoints,
+  buildAuthHeaders,
+  mergeRequestOverrides,
+  bytesToBase64,
+  base64ToBytes,
+  buildCompletionBody,
+  STREAM_USAGE_HOSTS,
+  streamUsageSupported,
+  withStreamUsage,
+  RETRYABLE_REQUEST_PARAMS,
+  unsupportedRequestParam,
+  withoutRequestParam,
+  buildEmbeddingsBody,
+  parseEmbeddingsResponse,
+  toWireCompletionRequest,
+  fromWireCompletionRequest,
+  AI_ERROR_COPY,
+  aiLengthLimitCopy,
+  isAiErrorCode,
+  isAiError,
+  makeAiError,
+  toAiError,
+  aiErrorCopy,
+  MODEL_LOAD_FAILED_PHRASES,
+  aiErrorCodeFromHttp,
+  thinkingChoices,
+  nearestThinkingLevel,
+  taskThinkingDefault,
+  resolveThinkingLevel,
+  thinkingOverrides,
+  thinkingLevelFrom,
+  withThinkingLevel,
+  THINKING_HEADROOM_TOKENS,
+  THINKING_DEFAULT_HEADROOM_TOKENS,
+  THINKING_MAX_TOKENS_CAP,
+  thinkingMaxTokens,
+  AI_AUDIENCES,
+  getAiAudience,
+  AI_REWRITE_VARIANTS,
+  getAiRewriteVariant,
+  REWRITE_CONTEXT_CHARS,
+  REWRITE_INSTRUCTION_MAX_CHARS,
+  REWRITE_LANGUAGE_MAX_CHARS,
+  REWRITE_SYSTEM_PROMPT,
+  TRANSLATE_SYSTEM_ADDENDUM,
+  EXPLAIN_SYSTEM_ADDENDUM,
+  TRANSLATE_DOCUMENT_NOTE,
+  escapeClosingTag,
+  trimRewriteContext,
+  normalizeRewriteLanguage,
+  rewriteInstruction,
+  rewriteSystemPrompt,
+  buildRewriteMessages,
+  EXPLAIN_MAX_TOKENS,
+  rewriteMaxTokens,
+  rewriteVisibleText,
+  finalizeRewriteText,
+  EXPLAIN_SYSTEM_PROMPT,
+  buildExplainMessages,
+  explainMaxTokens,
+  countMarkdownStructure,
+  checkMarkdownStructure,
+  parseLenientJson,
+  jsonRepairMessages,
+  JSON_SHAPE_HINT,
+  CHARS_PER_TOKEN,
+  headingsOutline,
+  budgetDocument,
+  SUMMARY_SHORT_DOCUMENT_CHARS,
+  SUMMARY_SYSTEM_PROMPT,
+  OUTLINE_SYSTEM_PROMPT,
+  coveragePercent,
+  buildSummaryMessages,
+  summaryMaxTokens,
+  summaryVisibleText,
+  summaryPreviewText,
+  finalizeSummary,
+  TITLE_MAX_CHARS,
+  TITLE_OUTLINE_MAX_ITEMS,
+  TITLE_SYSTEM_PROMPT,
+  renderHeadingOutline,
+  buildTitleMessages,
+  titleMaxTokens,
+  parseTitles,
+  PROPERTY_MAX_TAGS,
+  PROPERTY_DESCRIPTION_MAX_CHARS,
+  PROPERTY_TITLE_MAX_CHARS,
+  PROPERTY_VOCABULARY_MAX,
+  PROPERTIES_SYSTEM_PROMPT,
+  existingTagsOf,
+  buildPropertiesMessages,
+  propertiesMaxTokens,
+  parsePropertySuggestions,
+  AI_CLOUD_PRIVACY,
+  AI_HOST_PRIVACY,
+  aiConsentStepNote,
+  AI_SENDS_TEXT,
+  AI_SENDS_FALLBACK,
+  whatIsSent,
+  aiProviderPolicyForHost,
+  aiProviderPolicy,
+  aiConsentHost,
+  aiConsentText,
+  AI_NO_CONSENTS_TEXT,
+  aiConsentSummary,
+  AI_LOCAL_MIN_UNIFIED_GB,
+  AI_LOCAL_MIN_MEMORY_GB,
+  AI_LOCAL_MIN_VRAM_GB,
+  formatMemoryGb,
+  isLocalCapable,
+  modelMemoryBytes,
+  localSizeHint,
+  describeHardware,
+  AI_LOCAL_SMALL_MACHINE,
+  AI_LOCAL_ROUGH_GUESS,
+  recommendSetupPath,
+  vscodeLmAvailability,
+  modelParamsBillions,
+  modelSizeHint,
+  modelSizeHintFromBytes,
+  formatModelSize,
+  modelActiveParamsBillions,
+  modelMoeHint,
+  modelMoeFastHint,
+  localDefaultModel
+};
+//# sourceMappingURL=chunk-JZWKEBCI.js.map