blume 1.6.6 → 1.7.1

package/dist/cli/{chunk-9sh49q0h.js → chunk-ywn7t0pb.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-wd27zjcz.js";
 import {
   needsPlaygroundProxy
-} from "./chunk-vv3f8mb6.js";
+} from "./chunk-r99hynxh.js";
 
 // src/core/server-features.ts
 var serverFeatures = (config) => {
@@ -27,4 +27,4 @@ var serverFeatures = (config) => {
 export { serverFeatures };
 
 //# debugId=0DFA9D31AEDBECCC64756E2164756E21
-//# sourceMappingURL=chunk-9sh49q0h.js.map
+//# sourceMappingURL=chunk-ywn7t0pb.js.map

package/dist/cli/index.js

@@ -57,20 +57,20 @@ var main = defineCommand({
   },
   subCommands: {
     add: lazyCommand(commandMeta.add, () => import("./chunk-4trphnvy.js"), "addCommand"),
-    audit: lazyCommand(commandMeta.audit, () => import("./chunk-x1vrdjyk.js"), "auditCommand"),
-    build: lazyCommand(commandMeta.build, () => import("./chunk-vv237fp3.js"), "buildCommand"),
-    check: lazyCommand(commandMeta.check, () => import("./chunk-cnvm6k3e.js"), "checkCommand"),
-    dev: lazyCommand(commandMeta.dev, () => import("./chunk-ag1zyr5x.js"), "devCommand"),
-    doctor: lazyCommand(commandMeta.doctor, () => import("./chunk-m3p3wahd.js"), "doctorCommand"),
-    eject: lazyCommand(commandMeta.eject, () => import("./chunk-f75cqye8.js"), "ejectCommand"),
-    eval: lazyCommand(commandMeta.eval, () => import("./chunk-0ewz4trd.js"), "evalCommand"),
-    init: lazyCommand(commandMeta.init, () => import("./chunk-j00ezcg5.js"), "initCommand"),
+    audit: lazyCommand(commandMeta.audit, () => import("./chunk-h9ekmtz7.js"), "auditCommand"),
+    build: lazyCommand(commandMeta.build, () => import("./chunk-q56730e0.js"), "buildCommand"),
+    check: lazyCommand(commandMeta.check, () => import("./chunk-pdwg3q9g.js"), "checkCommand"),
+    dev: lazyCommand(commandMeta.dev, () => import("./chunk-mfm4sjwx.js"), "devCommand"),
+    doctor: lazyCommand(commandMeta.doctor, () => import("./chunk-52cwcqvp.js"), "doctorCommand"),
+    eject: lazyCommand(commandMeta.eject, () => import("./chunk-he2zfgah.js"), "ejectCommand"),
+    eval: lazyCommand(commandMeta.eval, () => import("./chunk-np8dmfb0.js"), "evalCommand"),
+    init: lazyCommand(commandMeta.init, () => import("./chunk-5gfw0q4j.js"), "initCommand"),
     "mcp-stdio": lazyCommand(commandMeta["mcp-stdio"], () => import("./chunk-jtb45atp.js"), "mcpStdioCommand"),
-    preview: lazyCommand(commandMeta.preview, () => import("./chunk-s4jn7f1q.js"), "previewCommand"),
-    sync: lazyCommand(commandMeta.sync, () => import("./chunk-s4k1pnvf.js"), "syncCommand"),
-    translate: lazyCommand(commandMeta.translate, () => import("./chunk-wkq5tbtq.js"), "translateCommand"),
-    validate: lazyCommand(commandMeta.validate, () => import("./chunk-n0y172hf.js"), "validateCommand"),
-    version: lazyCommand(commandMeta.version, () => import("./chunk-bawgnt8x.js"), "versionCommand")
+    preview: lazyCommand(commandMeta.preview, () => import("./chunk-j5f2wrj5.js"), "previewCommand"),
+    sync: lazyCommand(commandMeta.sync, () => import("./chunk-90pdhkpm.js"), "syncCommand"),
+    translate: lazyCommand(commandMeta.translate, () => import("./chunk-k0v1f8bb.js"), "translateCommand"),
+    validate: lazyCommand(commandMeta.validate, () => import("./chunk-aqjvpd03.js"), "validateCommand"),
+    version: lazyCommand(commandMeta.version, () => import("./chunk-6mq7qkve.js"), "versionCommand")
   }
 });
 loadEnvFiles(process.cwd());

package/dist/types/components/layout/nav-utils.d.ts

@@ -1,4 +1,4 @@
-import type { NavNode, NavTab } from "../../core/types.ts";
+import type { NavNode, NavTab, Navigation } from "../../core/types.ts";
 /** A flat, ordered page reference used for previous/next pagination. */
 export interface FlatPage {
     route: string;
@@ -58,3 +58,48 @@ export declare const getPagination: (flat: FlatPage[], route: string) => {
     next: FlatPage | null;
     prev: FlatPage | null;
 };
+/**
+ * A stable id for every group in a sidebar — `g<n>` by pre-order position in
+ * the full tree. The layout hands `NavTree` a scoped view of that tree (a
+ * tab's section, or the sidebar minus the tab sections), so positions within
+ * the rendered slice differ from page to page; these ids name the same group
+ * everywhere, which the drill-in panels and the deferred-section fragments
+ * (`/blume-nav/…`) rely on. Keyed by node identity: the scoped views reuse
+ * the full tree's node objects.
+ */
+export declare const navGroupIds: (sidebar: NavNode[]) => Map<NavNode, string>;
+/** Whether any group in a sidebar renders as a disclosure or a drill-in panel. */
+export declare const hasDeferrableGroups: (sidebar: NavNode[]) => boolean;
+/** One of the navigation trees a site renders, by URL segment. */
+export interface NavVariant {
+    /** `current`, or an archived version id. */
+    version: string;
+    /** `default`, or a locale code. */
+    locale: string;
+    navigation: Navigation;
+}
+/**
+ * The locale whose code must not appear as a fragment URL segment: the
+ * default locale while its URL prefix is hidden. Astro's i18n routing 404s any
+ * page URL carrying that locale's code as a segment (it expects the default
+ * locale to be unprefixed), so its trees are keyed `default` instead, the same
+ * way its page routes drop the prefix. `null` when every locale is prefixed
+ * or the site is single-locale.
+ */
+export declare const hiddenDefaultLocale: (i18n: {
+    defaultLocale: string;
+    hideDefaultLocalePrefix: boolean;
+} | null) => string | null;
+/**
+ * Every navigation tree the runtime data holds — the default, each locale's,
+ * and each archived version's per locale — keyed the way the deferred
+ * sidebar fragments' URLs are (`/blume-nav/<version>/<locale>/…`). An
+ * unlocalized version tree is keyed by `""` in the data; it maps to
+ * `default` here, as does the hidden-prefix default locale's (see
+ * `hiddenDefaultLocale`), whose current tree is `data.navigation` already.
+ */
+export declare const navVariants: (data: {
+    navigation: Navigation;
+    navigationByLocale: Record<string, Navigation>;
+    navigationByVersion: Record<string, Record<string, Navigation>>;
+}, hiddenDefault?: string | null) => NavVariant[];

package/dist/types/core/config-input.d.ts

@@ -628,6 +628,13 @@ export interface AskConfig {
      * limiting, and streaming. Accepts an absolute URL or root-relative path.
      */
     endpoint?: string;
+    /**
+     * Static request headers sent to the provider on every call — a
+     * caller-identifying header for a shared backend, for example. Values are
+     * written into the generated route as literals, so keep secrets in
+     * `apiKeyEnv` rather than here.
+     */
+    headers?: Record<string, string>;
     /**
      * Extra system-prompt text appended to the built-in instructions — use it
      * for identity, language, or tone. The built-in grounding behavior (answer

package/dist/types/core/schema.d.ts

@@ -336,6 +336,7 @@ declare const aiConfigSchema: z.ZodObject<{
         baseUrl: z.ZodOptional<z.ZodURL>;
         enabled: z.ZodDefault<z.ZodBoolean>;
         endpoint: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         instructions: z.ZodOptional<z.ZodString>;
         model: z.ZodDefault<z.ZodString>;
         provider: z.ZodDefault<z.ZodEnum<{
@@ -577,6 +578,7 @@ export declare const blumeConfigSchema: z.ZodObject<{
             baseUrl: z.ZodOptional<z.ZodURL>;
             enabled: z.ZodDefault<z.ZodBoolean>;
             endpoint: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             instructions: z.ZodOptional<z.ZodString>;
             model: z.ZodDefault<z.ZodString>;
             provider: z.ZodDefault<z.ZodEnum<{

package/dist/types/theme/fonts.d.ts

@@ -71,27 +71,27 @@ export declare const GOOGLE_FONTS: {
     "dm-sans": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     figtree: {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "fira-code": {
         category: "mono";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     geist: {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "geist-mono": {
         category: "mono";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "ibm-plex-mono": {
         category: "mono";
@@ -101,7 +101,7 @@ export declare const GOOGLE_FONTS: {
     "ibm-plex-sans": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "ibm-plex-serif": {
         category: "serif";
@@ -111,77 +111,77 @@ export declare const GOOGLE_FONTS: {
     inter: {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "inter-tight": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "jetbrains-mono": {
         category: "mono";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     lora: {
         category: "serif";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     manrope: {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     merriweather: {
         category: "serif";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "open-sans": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "playfair-display": {
         category: "serif";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "plus-jakarta-sans": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     roboto: {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "roboto-mono": {
         category: "mono";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "source-code-pro": {
         category: "mono";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "source-sans-3": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "source-serif-4": {
         category: "serif";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "space-grotesk": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
     "space-mono": {
         category: "mono";
@@ -191,7 +191,7 @@ export declare const GOOGLE_FONTS: {
     "work-sans": {
         category: "sans";
         family: string;
-        weights: number[];
+        weights: string[];
     };
 };
 export type FontSlug = keyof typeof GOOGLE_FONTS;

package/docs/02-deployment.mdx

@@ -141,6 +141,27 @@ When a feature needs a runtime secret, Blume warns at `blume dev`/`build` if it'
 
 Set them in `.env.local` for local dev and in your host's environment for production. Build-time secrets for search-index sync (Algolia, Orama Cloud, Typesense) are warned about separately during the sync step.
 
+## Build cache
+
+Blume keeps two caches a build can reuse. Astro's and Vite's caches live under `.blume/.cache/` (the content store and image transforms among them). Rendered [OG cards](/docs/discoverability/open-graph#card-cache) live in `node_modules/.cache/blume/og`, so a rebuild renders only the cards whose title, description, or branding changed. Whether a platform keeps that directory between deploys varies:
+
+- **Vercel** restores `node_modules/**` from its build cache, so cards carry over (the cache is 1 GB, retained for a month, and keyed per branch — a new branch starts from the production cache).
+- **Netlify** restores `node_modules`, so cards carry over.
+- **Cloudflare Workers Builds** persists only package-manager caches and, for a detected Astro project, `node_modules/.astro` — never `node_modules/.cache` — so every deploy renders every card there.
+- **GitHub Actions** and other runners you manage keep nothing unless you cache the directory yourself:
+
+```yaml
+- uses: actions/cache@v4
+  with:
+    path: node_modules/.cache/blume/og
+    key: blume-og-${{ runner.os }}-${{ hashFiles('**/bun.lock', '**/package-lock.json', '**/pnpm-lock.yaml') }}
+    restore-keys: blume-og-${{ runner.os }}-
+```
+
+Cards are keyed by content, so an imprecise key is fine: a restored cache only ever saves renders, never serves a wrong card.
+
+One install command discards the cache on every platform: `npm ci` deletes `node_modules` before installing. Keep `npm install`, `bun install`, or `pnpm install` as the install command to get the reuse.
+
 ## Build summary
 
 Every build prints a summary — output mode, adapter, resolved site URL, search provider, redirect count, sitemap and `llms.txt` status, and any enabled server features — so you can confirm what shipped (including anything auto-detected) before you deploy.

package/docs/08-faq.mdx

@@ -160,3 +160,24 @@ Patch oxfmt so it preserves the line break that sits directly against a `:::` fe
 :::warning[Version-pinned]
 The patch targets a specific oxfmt build — its diff references a file whose name is hashed per release (`dist/markdown-*.js`). When you bump oxfmt, regenerate the patch (e.g. `bun patch oxfmt`) or check whether the upstream fix has landed and the patch is no longer needed.
 :::
+
+## Why does Knip report my `blume.config.ts` dependencies as unused?
+
+[Knip](https://knip.dev) only follows imports from files it knows are entry points, and it learns those from its built-in plugins. There is no Blume plugin yet, and Knip's Astro plugin doesn't switch on either: it looks for `astro` in your own `package.json`, but a Blume project depends on `blume`, and the generated `.blume/` Astro project is gitignored, so Knip never sees it. Nothing references `blume.config.ts`, so any package it imports gets reported as unused.
+
+Register the files Blume loads from your project root as entries. In `knip.json`:
+
+```json knip.json
+{
+  "entry": [
+    "blume.config.{ts,mjs,js}",
+    "components.{ts,tsx}",
+    "islands/**/*.{ts,tsx}",
+    "pages/**/*"
+  ]
+}
+```
+
+In a monorepo, put the same `entry` list under the docs workspace in `workspaces` instead. Drop any line for a convention you don't use — `components.ts` for [component overrides](/docs/configuration/customization#component-overrides), `islands/` for [interactive islands](/docs/configuration/customization#interactive-islands), and `pages/` for [custom pages](/docs/configuration/customization#custom-pages) (adjust the last one if you've changed `content.pages`).
+
+Knip can only follow real imports. A package that's only named inside a string — say, an [Astro integration](/docs/configuration/customization#astro-integrations) that calls `injectScript("page", "import('some-package')")` — still needs an `ignoreDependencies` entry.

package/docs/configuration/ask-ai.mdx

@@ -166,6 +166,22 @@ ai: {
 
 Set `apiKeyEnv` (and, for the named providers, `baseUrl`) on any backend to point at a different env var or proxy.
 
+To send static request headers with every call — a caller-identifying header for a shared backend, say, so its own observability or rate limiting can tell your docs apart from other traffic — set `headers`. It works on every backend, including the gateway:
+
+```ts blume.config.ts lineNumbers
+ai: {
+  ask: {
+    enabled: true,
+    provider: "openai-compatible",
+    baseUrl: "https://llm.internal.example.com/v1",
+    apiKeyEnv: "INTERNAL_LLM_API_KEY",
+    headers: { "X-Caller-Id": "docs" },
+  },
+}
+```
+
+The values are written into the generated route as-is, so keep secrets in `apiKeyEnv` rather than in `headers`. The API key's `Authorization` header is applied first, so a custom header can't displace it.
+
 :::note
 **Inkeep** answers from the content you've indexed in the Inkeep dashboard — it runs its own retrieval — so Blume leaves it ungrounded. Every other backend is [grounded](#grounding) in this site's pages.
 :::

package/docs/content/navigation.mdx

@@ -69,6 +69,8 @@ navigation: {
 `page` mode keeps deep sections tidy — reach for it when groups have many children and you'd rather drill into them than scroll past them.
 :::
 
+In both `group` and `page` mode, a section that isn't open on the current page is left out of that page's HTML and fetched the first time it's opened (it's prefetched as soon as the pointer or focus reaches its row, so the open is usually instant, and a section fetched once is kept for the rest of the visit). On a large site this is most of a page's weight: only the open section's rows ship with the page. The rows are prerendered fragments under `/blume-nav/`, so they need no server. Readers without JavaScript see the open section and the group rows; the sitemap, the previous/next links, and the open section keep every page reachable for crawlers.
+
 ### Per-group overrides
 
 Any generated group can opt out of the global mode — no explicit sidebar required. Set `display` in the folder's [`meta.ts`](/docs/content/meta), or — when the folder has an `index` page — under `sidebar` in that page's frontmatter, and only that group changes:

package/docs/content/sources.mdx

@@ -163,7 +163,7 @@ A read token for a private dataset comes from the `SANITY_TOKEN` environment var
 
 ## Notion
 
-The built-in `notion` source turns a Notion database into a collection: each row becomes a page, its properties become frontmatter, and its block tree becomes MDX. Callouts, toggles, columns, and code blocks map to the matching Blume components. `@notionhq/client` (v5 or later) is an optional peer dependency; Blume reads the database through its first data source.
+The built-in `notion` source turns a Notion database into a collection: each row becomes a page, its properties become frontmatter, and its block tree becomes MDX. Callouts, toggles, columns, and code blocks map to the matching Blume components. Video blocks become a `<YouTube>` embed when they hold a YouTube link and a `<video>` player otherwise, with the block's caption as a `<Frame>` caption either way; a link to a video page rather than a media file (a Vimeo or Loom URL, say) is reported as a warning instead of embedded. `@notionhq/client` (v5 or later) is an optional peer dependency; Blume reads the database through its first data source.
 
 ```ts blume.config.ts
 import { defineConfig } from "blume";
@@ -185,7 +185,7 @@ export default defineConfig({
 });
 ```
 
-The integration token comes from the `NOTION_TOKEN` environment variable (share the database with your integration). By default every page is imported; set `publishedValue` to make the `Status` property a publish gate — any other value then maps to `draft: true`, which production builds drop. **Notion image URLs are signed and expire**, so the adapter downloads them at build time into the site's assets and rewrites the references — a CMS image never rots a static build. API calls are paced through a small request pool (3 at a time, matching Notion's per-integration rate limit) so databases with hundreds of pages import without tripping `429` responses; set `concurrency` on the source to tune it.
+The integration token comes from the `NOTION_TOKEN` environment variable (share the database with your integration). By default every page is imported; set `publishedValue` to make the `Status` property a publish gate — any other value then maps to `draft: true`, which production builds drop. **Notion image and video URLs are signed and expire**, so the adapter downloads them at build time into the site's assets and rewrites the references — a CMS asset never rots a static build. API calls are paced through a small request pool (3 at a time, matching Notion's per-integration rate limit) so databases with hundreds of pages import without tripping `429` responses; set `concurrency` on the source to tune it.
 
 ## Preview and sync
 

package/docs/content/syntax.mdx

@@ -384,7 +384,7 @@ flowchart LR
 ```
 ````
 
-Diagrams render on the client, so this is an MDX-only feature, and the Mermaid library loads only on pages that include one. Diagrams use Mermaid's dagre layout and classic look by default; opt a single diagram into another layout or look through Mermaid front matter (a `config:` block with `layout: elk` or `look: neo`), and the ELK engine loads only for diagrams that ask for it. The rest of this section is a gallery of common types — see the [Mermaid docs](https://mermaid.js.org/intro/) for the full list.
+Diagrams render on the client, so this is an MDX-only feature, and the Mermaid library loads only on pages that include one; a site with no diagram doesn't ship it at all. Diagrams use Mermaid's dagre layout and classic look by default; opt a single diagram into another layout or look through Mermaid front matter (a `config:` block with `layout: elk` or `look: neo`), and the ELK engine loads only for diagrams that ask for it. The rest of this section is a gallery of common types — see the [Mermaid docs](https://mermaid.js.org/intro/) for the full list.
 
 ### Flowchart
 

package/docs/discoverability/open-graph.mdx

@@ -94,6 +94,10 @@ Google families are fetched at build — so a build that uses them needs network
 
 An explicit `og.fonts: []` opts out entirely: cards keep the built-in font even when `theme.fonts` is set.
 
+## Card cache
+
+Rendered cards are cached on disk between builds, keyed by everything that decides their pixels: the page title and description, the brand text, logo, palette, footer text, and fonts (a local font file by its contents), plus the Blume version. A rebuild renders only the cards whose inputs changed and reads the rest back; the build log reports how many were reused. The cache lives in `node_modules/.cache/blume/og`; on a platform that keeps `node_modules` between builds (Vercel and Netlify do, Cloudflare does not) or a CI runner that caches that directory (see [Build cache](/docs/deployment#build-cache)), a deploy that touches a handful of pages re-renders a handful of cards. Cards that no page asked for are removed after each build, so the directory only ever holds the current site's cards.
+
 ## Custom page titles
 
 A custom [`.astro` page](/docs/advanced/custom-pages) has no frontmatter to read, so its generated card is titled by humanizing the last URL segment of its route — `/getting-started` becomes "Getting Started", but `/cli` becomes "Cli". Name those cards explicitly with `og.titles`, keyed by route (`"/"` addresses the home, whose card otherwise carries the site title):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blume",
-  "version": "1.6.6",
+  "version": "1.7.1",
   "description": "Documentation that's fast, AI-ready, and zero-config.",
   "keywords": [
     "astro",

package/src/ai/ask.ts

@@ -7,16 +7,31 @@ import type { AskAiConfig } from "../core/schema.ts";
  * AI SDK's OpenAI-compatible provider.
  */
 export type AskBackend =
-  | { kind: "gateway"; model: string }
-  | { apiKeyEnv: string; kind: "openrouter"; model: string }
+  | { headers?: AskHeaders; kind: "gateway"; model: string }
+  | {
+      apiKeyEnv: string;
+      headers?: AskHeaders;
+      kind: "openrouter";
+      model: string;
+    }
   | {
       apiKeyEnv: string;
       baseUrl: string;
+      headers?: AskHeaders;
       kind: "openai-compatible";
       model: string;
       name: string;
     };
 
+/**
+ * Static request headers (`ai.ask.headers`) every backend forwards to its
+ * provider factory. Every provider Blume generates against accepts the same
+ * `headers` option, so the map travels unchanged; the OpenAI-compatible
+ * provider applies them after the `Authorization` header it derives from the
+ * API key, so a custom header can't displace auth.
+ */
+export type AskHeaders = Record<string, string>;
+
 interface AskPreset {
   apiKeyEnv: string;
   baseUrl?: string;
@@ -69,17 +84,28 @@ const ASK_PRESETS: AskPresetRegistry = {
 
 const DEFAULT_MODEL = "openai/gpt-5.5";
 
+/**
+ * The `headers` field every backend variant shares. An empty map is dropped so
+ * the generated route only carries a `headers` option when there is something
+ * to send.
+ */
+const askHeadersField = (ask?: AskAiConfig): { headers?: AskHeaders } =>
+  ask?.headers && Object.keys(ask.headers).length > 0
+    ? { headers: ask.headers }
+    : {};
+
 /** Resolve the `ai.ask` config into the backend the endpoint is built against. */
 export const resolveAskBackend = (ask?: AskAiConfig): AskBackend => {
   const provider = ask?.provider ?? "gateway";
   const model = ask?.model ?? DEFAULT_MODEL;
+  const headers = askHeadersField(ask);
   if (provider === "gateway") {
-    return { kind: "gateway", model };
+    return { ...headers, kind: "gateway", model };
   }
   const preset = ASK_PRESETS[provider];
   const apiKeyEnv = ask?.apiKeyEnv ?? preset?.apiKeyEnv ?? "API_KEY";
   if (provider === "openrouter") {
-    return { apiKeyEnv, kind: "openrouter", model };
+    return { apiKeyEnv, ...headers, kind: "openrouter", model };
   }
   // `llmgateway`, `inkeep`, and the generic `openai-compatible` provider all
   // stream through the AI SDK's OpenAI-compatible provider. The schema requires
@@ -87,6 +113,7 @@ export const resolveAskBackend = (ask?: AskAiConfig): AskBackend => {
   return {
     apiKeyEnv,
     baseUrl: ask?.baseUrl ?? preset?.baseUrl ?? "",
+    ...headers,
     kind: OPENAI_COMPATIBLE,
     model,
     name: preset?.name ?? OPENAI_COMPATIBLE,