blume 2.0.3 → 2.1.0

package/dist/types/ai/ask.d.ts

@@ -34,9 +34,24 @@ export interface AssistantAdapterOptions {
      */
     providerOptions?: AssistantProviderOptions;
 }
+/** The shared option schema, with the adapter's own key env var default. */
+export declare const sharedOptions: (apiKeyEnv: string) => {
+    apiKeyEnv: z.ZodDefault<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+};
+export declare const GATEWAY_API_KEY_ENV = "AI_GATEWAY_API_KEY";
 /** Options for {@link gateway}. */
 export interface AssistantGatewayOptions extends AssistantAdapterOptions {
-    /** A `provider/model` id routed by the gateway. Defaults to `openai/gpt-5.5`. */
+    /**
+     * Narration only: how the voice should sound, for speech models that take
+     * instructions ("Read calmly, like a teacher").
+     */
+    instructions?: string;
+    /**
+     * A `provider/model` id routed by the gateway. Defaults to `openai/gpt-5.5`
+     * for the assistant and `openai/tts-1-hd` for narration.
+     */
     model?: string;
     /**
      * How much the model reasons before answering. Sent as the AI SDK's
@@ -45,6 +60,8 @@ export interface AssistantGatewayOptions extends AssistantAdapterOptions {
      * offer the level you pick. Omitted keeps the model's default.
      */
     reasoning?: AssistantReasoning;
+    /** Narration only: the speech model's voice. Defaults to `alloy`. */
+    voice?: string;
 }
 export type AssistantGatewayAdapter = AdapterDescriptor<"gateway", AssistantGatewayOptions>;
 export declare const gatewayAdapterSchema: z.ZodObject<{
@@ -67,12 +84,193 @@ export declare const gatewayAdapterSchema: z.ZodObject<{
     runtimeDeps: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 /**
- * Route the assistant through the Vercel AI Gateway (the default). `model` is a
+ * Route the assistant through the Vercel AI Gateway (the default), or generate
+ * narration audio with one of its speech models. `model` is a
  * `provider/model` string; the key is `AI_GATEWAY_API_KEY`, or Vercel's OIDC
  * token when deployed there. Needs no provider SDK beyond the `ai` package
  * Blume ships.
  */
 export declare const gateway: (options?: AssistantGatewayOptions) => AssistantGatewayAdapter;
+/** Options for {@link openai}. */
+export interface AssistantOpenAIOptions extends AssistantAdapterOptions {
+    /**
+     * An OpenAI-compatible endpoint to call instead of OpenAI
+     * (`https://llm.internal.example.com/v1`): a self-hosted model or an
+     * internal gateway. The route then talks Chat Completions through
+     * `@ai-sdk/openai-compatible`, and the docs tools are off unless
+     * `ai.assistant.tools` turns them on, since the model may not call tools.
+     */
+    baseUrl?: string;
+    /** The model id (`gpt-5.5`). */
+    model: string;
+    /**
+     * The provider name the AI SDK reports, which a custom endpoint also reads
+     * its `providerOptions` under. Defaults to `openai`, or `openai-compatible`
+     * with a `baseUrl`.
+     */
+    name?: string;
+    /**
+     * How much the model reasons before answering, sent as `reasoning_effort`;
+     * with a `baseUrl`, the endpoint has to accept that parameter. Omitted
+     * keeps the model's default.
+     */
+    reasoning?: AssistantReasoning;
+}
+export type AssistantOpenAIAdapter = AdapterDescriptor<"openai", AssistantOpenAIOptions>;
+export declare const openaiAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"openai">;
+    options: z.ZodObject<{
+        baseUrl: z.ZodOptional<z.ZodURL>;
+        model: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Route the assistant to OpenAI, or to any OpenAI-compatible endpoint with
+ * `baseUrl`. Reads `OPENAI_API_KEY` and needs `@ai-sdk/openai` installed; a
+ * custom endpoint needs `@ai-sdk/openai-compatible` instead, since most
+ * don't serve OpenAI's Responses API.
+ */
+export declare const openai: (options: AssistantOpenAIOptions) => AssistantOpenAIAdapter;
+/**
+ * Options for the deprecated {@link openaiCompatible}: {@link openai}'s, with
+ * the endpoint and its key env var required.
+ *
+ * @deprecated Use {@link AssistantOpenAIOptions}.
+ */
+export interface AssistantOpenAICompatibleOptions extends AssistantOpenAIOptions {
+    apiKeyEnv: string;
+    baseUrl: string;
+}
+/** @deprecated Use {@link AssistantOpenAIAdapter}. */
+export type AssistantOpenAICompatibleAdapter = AssistantOpenAIAdapter;
+/**
+ * Route the assistant through an OpenAI-compatible endpoint.
+ *
+ * @deprecated Use `openai({ baseUrl, model, apiKeyEnv })`, which this calls.
+ */
+export declare const openaiCompatible: (options: AssistantOpenAICompatibleOptions) => AssistantOpenAIAdapter;
+/** Options for {@link anthropic}. */
+export interface AssistantAnthropicOptions extends AssistantAdapterOptions {
+    /** The Claude model id (`claude-sonnet-5`). */
+    model: string;
+    /**
+     * How much the model reasons before answering. The Anthropic provider
+     * maps the level to the model's thinking: an effort on models with
+     * adaptive thinking, a thinking budget on older ones, and thinking off for
+     * `"none"`. Omitted keeps the model's default.
+     */
+    reasoning?: AssistantReasoning;
+}
+export type AssistantAnthropicAdapter = AdapterDescriptor<"anthropic", AssistantAnthropicOptions>;
+export declare const anthropicAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"anthropic">;
+    options: z.ZodObject<{
+        model: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Route the assistant to Anthropic's Claude API. Reads `ANTHROPIC_API_KEY`
+ * and needs `@ai-sdk/anthropic` installed.
+ */
+export declare const anthropic: (options: AssistantAnthropicOptions) => AssistantAnthropicAdapter;
+/** Options for {@link gemini}. */
+export interface AssistantGeminiOptions extends AssistantAdapterOptions {
+    /** The Gemini model id (`gemini-3.5-flash`). */
+    model: string;
+    /**
+     * How much the model reasons before answering. The Google provider maps
+     * the level to the model's thinking level, or to a thinking budget on
+     * models that take one. Omitted keeps the model's default.
+     */
+    reasoning?: AssistantReasoning;
+}
+export type AssistantGeminiAdapter = AdapterDescriptor<"gemini", AssistantGeminiOptions>;
+export declare const geminiAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"gemini">;
+    options: z.ZodObject<{
+        model: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Route the assistant to Google's Gemini API. Reads `GEMINI_API_KEY` and
+ * needs `@ai-sdk/google` installed.
+ */
+export declare const gemini: (options: AssistantGeminiOptions) => AssistantGeminiAdapter;
+/** Options for {@link grok}. */
+export interface AssistantGrokOptions extends AssistantAdapterOptions {
+    /** The Grok model id (`grok-4.7`). */
+    model: string;
+    /**
+     * How much the model reasons before answering, sent as xAI's reasoning
+     * effort on the models that take one. Omitted keeps the model's default.
+     */
+    reasoning?: AssistantReasoning;
+}
+export type AssistantGrokAdapter = AdapterDescriptor<"grok", AssistantGrokOptions>;
+export declare const grokAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"grok">;
+    options: z.ZodObject<{
+        model: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Route the assistant to xAI's Grok models. Reads `XAI_API_KEY` and needs
+ * `@ai-sdk/xai` installed.
+ */
+export declare const grok: (options: AssistantGrokOptions) => AssistantGrokAdapter;
 /** Options for {@link openrouter}. */
 export interface AssistantOpenRouterOptions extends AssistantAdapterOptions {
     /** The OpenRouter model id (`anthropic/claude-sonnet-4-5`). */
@@ -176,53 +374,8 @@ export declare const inkeepAdapterSchema: z.ZodObject<{
  * Reads `INKEEP_API_KEY` and needs `@ai-sdk/openai-compatible` installed.
  */
 export declare const inkeep: (options: AssistantInkeepOptions) => AssistantInkeepAdapter;
-/** Options for {@link openaiCompatible}. */
-export interface AssistantOpenAICompatibleOptions extends AssistantAdapterOptions {
-    /** Name of the env var holding the endpoint's API key. */
-    apiKeyEnv: string;
-    /** The endpoint's base URL (`https://my-gateway.example.com/v1`). */
-    baseUrl: string;
-    /** The model id the endpoint serves. */
-    model: string;
-    /** The provider name the AI SDK reports. Defaults to `openai-compatible`. */
-    name?: string;
-    /**
-     * How much the model reasons before answering, sent in the request as
-     * `reasoning_effort`, so the endpoint has to accept that parameter.
-     * Omitted keeps the model's default.
-     */
-    reasoning?: AssistantReasoning;
-}
-export type AssistantOpenAICompatibleAdapter = AdapterDescriptor<"openai-compatible", AssistantOpenAICompatibleOptions>;
-export declare const openaiCompatibleAdapterSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"openai-compatible">;
-    options: z.ZodObject<{
-        apiKeyEnv: z.ZodString;
-        baseUrl: z.ZodURL;
-        model: z.ZodString;
-        name: z.ZodDefault<z.ZodString>;
-        reasoning: z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            minimal: "minimal";
-            low: "low";
-            medium: "medium";
-            high: "high";
-            xhigh: "xhigh";
-        }>>;
-        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
-    }, z.core.$strict>;
-    requiredSecrets: z.ZodArray<z.ZodString>;
-    runtimeDeps: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-/**
- * Route the assistant through any OpenAI-compatible endpoint: supply its `baseUrl`,
- * the `model` it serves, and the env var holding its key. Needs
- * `@ai-sdk/openai-compatible` installed.
- */
-export declare const openaiCompatible: (options: AssistantOpenAICompatibleOptions) => AssistantOpenAICompatibleAdapter;
-/** Which backend answers the assistant: the value of `gateway()`, `openrouter()`, … */
-export type AssistantAdapter = AssistantGatewayAdapter | AssistantOpenRouterAdapter | AssistantLlmGatewayAdapter | AssistantInkeepAdapter | AssistantOpenAICompatibleAdapter;
+/** Which backend answers the assistant: the value of `gateway()`, `openai()`, … */
+export type AssistantAdapter = AssistantGatewayAdapter | AssistantOpenAIAdapter | AssistantAnthropicAdapter | AssistantGeminiAdapter | AssistantGrokAdapter | AssistantOpenRouterAdapter | AssistantLlmGatewayAdapter | AssistantInkeepAdapter;
 /**
  * Error params for `ai.assistant`: a 1.x flat provider field (`model`, `apiKeyEnv`,
  * `baseUrl`, `headers`, `reasoning`) names the adapter call it moves into —
@@ -256,9 +409,11 @@ export declare const assistantAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"openrouter">;
+    kind: z.ZodLiteral<"openai">;
     options: z.ZodObject<{
+        baseUrl: z.ZodOptional<z.ZodURL>;
         model: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
         reasoning: z.ZodOptional<z.ZodEnum<{
             none: "none";
             minimal: "minimal";
@@ -274,9 +429,8 @@ export declare const assistantAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"llmgateway">;
+    kind: z.ZodLiteral<"anthropic">;
     options: z.ZodObject<{
-        baseUrl: z.ZodDefault<z.ZodURL>;
         model: z.ZodString;
         reasoning: z.ZodOptional<z.ZodEnum<{
             none: "none";
@@ -293,10 +447,35 @@ export declare const assistantAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"inkeep">;
+    kind: z.ZodLiteral<"gemini">;
+    options: z.ZodObject<{
+        model: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"grok">;
     options: z.ZodObject<{
-        baseUrl: z.ZodDefault<z.ZodURL>;
         model: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
         apiKeyEnv: z.ZodDefault<z.ZodString>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
@@ -304,12 +483,9 @@ export declare const assistantAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"openai-compatible">;
+    kind: z.ZodLiteral<"openrouter">;
     options: z.ZodObject<{
-        apiKeyEnv: z.ZodString;
-        baseUrl: z.ZodURL;
         model: z.ZodString;
-        name: z.ZodDefault<z.ZodString>;
         reasoning: z.ZodOptional<z.ZodEnum<{
             none: "none";
             minimal: "minimal";
@@ -318,6 +494,37 @@ export declare const assistantAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
             high: "high";
             xhigh: "xhigh";
         }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"llmgateway">;
+    options: z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodURL>;
+        model: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>>;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"inkeep">;
+    options: z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodURL>;
+        model: z.ZodString;
+        apiKeyEnv: z.ZodDefault<z.ZodString>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
     }, z.core.$strict>;
@@ -357,6 +564,12 @@ export interface AskBackendTemplate {
 export interface AskBackend {
     /** Whether Blume grounds answers in the docs (Inkeep retrieves itself). */
     grounded: boolean;
+    /**
+     * Whether the docs tools are on when `ai.assistant.tools` is unset: yes for
+     * the hosted model catalogs, whose models call tools, and no for an
+     * OpenAI-compatible backend, which may be a local model that can't.
+     */
+    toolsByDefault: boolean;
     kind: AssistantAdapterKind;
     /** Human-readable adapter name for diagnostics ("AI Gateway"). */
     label: string;

package/dist/types/ai/index.d.ts

@@ -19,6 +19,6 @@
  * schema validates and the generated `/api/ask` route inlines as literals;
  * nothing here runs at request time.
  */
-export { gateway, inkeep, llmgateway, openaiCompatible, openrouter, } from "./ask.ts";
-export type { AssistantAdapter, AssistantAdapterOptions, AssistantGatewayAdapter, AssistantGatewayOptions, AssistantInkeepAdapter, AssistantInkeepOptions, AssistantLlmGatewayAdapter, AssistantLlmGatewayOptions, AssistantOpenAICompatibleAdapter, AssistantOpenAICompatibleOptions, AssistantOpenRouterAdapter, AssistantOpenRouterOptions, AssistantProviderOptions, AssistantReasoning, } from "./ask.ts";
+export { anthropic, gateway, gemini, grok, inkeep, llmgateway, openai, openaiCompatible, openrouter, } from "./ask.ts";
+export type { AssistantAdapter, AssistantAdapterOptions, AssistantAnthropicAdapter, AssistantAnthropicOptions, AssistantGatewayAdapter, AssistantGatewayOptions, AssistantGeminiAdapter, AssistantGeminiOptions, AssistantGrokAdapter, AssistantGrokOptions, AssistantInkeepAdapter, AssistantInkeepOptions, AssistantLlmGatewayAdapter, AssistantLlmGatewayOptions, AssistantOpenAIAdapter, AssistantOpenAICompatibleAdapter, AssistantOpenAICompatibleOptions, AssistantOpenAIOptions, AssistantOpenRouterAdapter, AssistantOpenRouterOptions, AssistantProviderOptions, AssistantReasoning, } from "./ask.ts";
 export type { AdapterDescriptor } from "../core/adapter.ts";

package/dist/types/ai/site-skill.d.ts

@@ -0,0 +1,26 @@
+import type { BlumeProject } from "../core/project-graph.ts";
+import type { SkillArtifact } from "./skills.ts";
+/**
+ * The site's own agent skill (`agents.skillMd`): a `SKILL.md` in the Agent
+ * Skills format, built from what the build already knows — the site's title
+ * and description, how to read any page as Markdown, llms.txt and the MCP
+ * server, the API references, and a map of the docs with each page's one-line
+ * description. No model writes it, so it costs nothing and is current with
+ * every build: a guide to the docs rather than a summary of the product. A
+ * hand-written skill of the same name in `agents.skills` replaces it.
+ */
+/** The most pages the map lists; llms.txt holds the rest. */
+export declare const MAX_SKILL_PAGES = 200;
+/** Where the site skill is served besides the discovery index. */
+export declare const SKILL_MD_PATH = "/skill.md";
+/**
+ * The site skill's name: the title as a skill name (lowercase alphanumerics
+ * and single hyphens), else the site's host, for a title with no Latin
+ * letters in it.
+ */
+export declare const siteSkillName: (project: BlumeProject) => string;
+/**
+ * The generated site skill, or `null` when `agents.skillMd` is off or there
+ * is no `deployment.site` to make its links absolute.
+ */
+export declare const buildSiteSkill: (project: BlumeProject) => SkillArtifact | null;

package/dist/types/ai/skills.d.ts

@@ -10,6 +10,8 @@ import type { ResolvedConfig } from "../core/schema.ts";
  */
 export declare const AGENT_SKILLS_DIR = "/.well-known/agent-skills";
 export declare const AGENT_SKILLS_INDEX_PATH = "/.well-known/agent-skills/index.json";
+/** The Agent Skills spec caps `description` at 1024 characters. */
+export declare const SKILL_DESCRIPTION_MAX = 1024;
 /** One publishable skill artifact plus its index entry. */
 export interface SkillArtifact {
     /** Raw bytes to publish (the digest is computed over exactly these). */
@@ -38,6 +40,20 @@ export interface CollectedSkills {
  * with a warning naming both.
  */
 export declare const collectSkills: (dir: string) => Promise<CollectedSkills>;
+/** A skill that is one `SKILL.md`, published verbatim. */
+export declare const skillMdArtifact: (name: string, description: string, markdown: string) => SkillArtifact;
+/**
+ * Whether the build generates the site's own skill (`agents.skillMd`): on,
+ * and with a `deployment.site` to make its links absolute, since an installed
+ * skill is read away from the site.
+ */
+export declare const generatesSiteSkill: (config: ResolvedConfig) => boolean;
+/**
+ * Whether a skills discovery index is served: from `agents.skills`, or for
+ * the generated site skill alone. On an advertised config (see
+ * `advertisedConfig`), both are already switched off when nothing published.
+ */
+export declare const servesSkillsIndex: (config: ResolvedConfig) => boolean;
 /**
  * The discovery index (v0.2.0 schema). Artifact URLs are path-absolute under
  * `deployment.base` — the RFC resolves them against the index origin.

package/dist/types/astro/integration.d.ts

@@ -1,6 +1,7 @@
 import type { AstroIntegration } from "astro";
 import type { CustomPageRoute } from "../core/custom-pages.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
+import type { CompiledRedirect } from "../core/redirect-patterns.ts";
 import type { Diagnostic } from "../core/types.ts";
 /**
  * Hand the scanned project to the integration ahead of `build()`, so its
@@ -66,6 +67,13 @@ export interface BlumeIntegrationOptions {
      * its already-scanned project instead.
      */
     buildArtifactsRoot?: string;
+    /**
+     * The pattern redirects (`/beta/:slug*`), compiled against base-less
+     * request paths (see `core/redirect-patterns.ts`). Astro's own `redirects`
+     * carry only the exact ones, since it can't prerender a pattern's pages, so
+     * the dev server answers these itself.
+     */
+    redirects?: CompiledRedirect[];
 }
 /**
  * Blume's Astro integration. Mounts user-authored pages from `pages/` into the

package/dist/types/captcha/hcaptcha.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+/** Options for {@link hcaptcha}. */
+export interface HcaptchaOptions {
+    /** The site key, from the hCaptcha dashboard. */
+    siteKey: string;
+}
+export declare const hcaptchaOptionsSchema: z.ZodObject<{
+    siteKey: z.ZodString;
+}, z.core.$strict>;
+export type HcaptchaAdapter = AdapterDescriptor<"hcaptcha", HcaptchaOptions>;
+export declare const hcaptchaAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"hcaptcha">;
+    options: z.ZodObject<{
+        siteKey: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** Where the assistant's route checks an hCaptcha token. */
+export declare const HCAPTCHA_VERIFY_URL = "https://api.hcaptcha.com/siteverify";
+/**
+ * hCaptcha, as an invisible check: most readers never see a challenge. The
+ * site key is public and goes to the browser; the secret the route checks
+ * tokens with comes from `HCAPTCHA_SECRET_KEY`.
+ */
+export declare const hcaptcha: (options: HcaptchaOptions) => HcaptchaAdapter;

package/dist/types/captcha/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Bot checks for the assistant (`ai.assistant.captcha` in `blume.config.ts`).
+ * The assistant gets a token from the check before each question and the
+ * generated route verifies it before calling the model:
+ *
+ * ```ts
+ * import { defineConfig } from "blume";
+ * import { turnstile } from "blume/captcha";
+ *
+ * export default defineConfig({
+ *   ai: {
+ *     assistant: {
+ *       enabled: true,
+ *       captcha: turnstile({ siteKey: "0x4AAAAAAA…" }),
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * Each factory returns a plain descriptor (see `core/adapter.ts`); the browser
+ * half is `client.ts`, the server half `verify.ts`.
+ */
+export type { AdapterDescriptor, JsonValue } from "../core/adapter.ts";
+export { hcaptcha } from "./hcaptcha.ts";
+export type { HcaptchaAdapter, HcaptchaOptions } from "./hcaptcha.ts";
+export type { CaptchaAdapter, CaptchaSettings } from "./schema.ts";
+export { turnstile } from "./turnstile.ts";
+export type { TurnstileAdapter, TurnstileOptions } from "./turnstile.ts";

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * The configured bot check, as its factory returned it. Anything that isn't
+ * one fails with the adapter hint; an adapter's own option errors keep their
+ * messages.
+ */
+export declare const captchaAdapterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"hcaptcha">;
+    options: z.ZodObject<{
+        siteKey: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"turnstile">;
+    options: z.ZodObject<{
+        siteKey: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type CaptchaAdapter = z.output<typeof captchaAdapterSchema>;
+/** What the browser needs to run the check: never the secret. */
+export interface CaptchaSettings {
+    kind: CaptchaAdapter["kind"];
+    siteKey: string;
+}
+/** The public half of an adapter, for the data snapshot. */
+export declare const captchaSettings: (adapter: CaptchaAdapter) => CaptchaSettings;

package/dist/types/captcha/turnstile.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+/** Options for {@link turnstile}. */
+export interface TurnstileOptions {
+    /** The widget's site key, from the Cloudflare dashboard. */
+    siteKey: string;
+}
+export declare const turnstileOptionsSchema: z.ZodObject<{
+    siteKey: z.ZodString;
+}, z.core.$strict>;
+export type TurnstileAdapter = AdapterDescriptor<"turnstile", TurnstileOptions>;
+export declare const turnstileAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"turnstile">;
+    options: z.ZodObject<{
+        siteKey: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** Where the assistant's route checks a Turnstile token. */
+export declare const TURNSTILE_VERIFY_URL = "https://challenges.cloudflare.com/turnstile/v0/siteverify";
+/**
+ * Cloudflare Turnstile. The site key is public and goes to the browser; the
+ * secret key the route checks tokens with comes from `TURNSTILE_SECRET_KEY`.
+ * Set the widget to Invisible or Managed in the Cloudflare dashboard: most
+ * readers never see a challenge.
+ */
+export declare const turnstile: (options: TurnstileOptions) => TurnstileAdapter;