@sanity/ailf 0.4.1 → 1.0.0

package/dist/pipeline/compiler/mode-handlers/mcp-assertions.js

@@ -0,0 +1,277 @@
+/**
+ * MCP-specific assertion types — ergonomic assertions for MCP server testing.
+ *
+ * Each assertion type compiles down to a Promptfoo `javascript` assertion
+ * with the appropriate validation logic. The developer writes:
+ *
+ * ```typescript
+ * assertions: [
+ *   { type: "tool-called", value: "getDocument" },
+ *   { type: "tool-input-matches", value: { documentId: "doc-123" } },
+ *   { type: "tool-output-matches", value: { title: "Hello" } },
+ *   { type: "error-returned", value: { code: -32602 } },
+ * ]
+ * ```
+ *
+ * The compiler transforms these into Promptfoo-compatible `javascript`
+ * assertions that inspect the tool call trace in the evaluation output.
+ *
+ * @see docs/exec-plans/architecture-overhaul/phase-3-mcp-server-mode.md
+ */
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Build MCP-specific assertions from task assertion definitions.
+ *
+ * Handles both MCP-specific types (tool-called, tool-input-matches, etc.)
+ * and standard assertion types (contains, llm-rubric, etc.) which are
+ * passed through unchanged.
+ */
+export function buildMCPAssertions(assertions, context) {
+    const result = [];
+    const warnings = [];
+    for (const assertion of assertions) {
+        const mapped = mapMCPAssertion(assertion, context, warnings);
+        if (mapped) {
+            result.push(mapped);
+        }
+    }
+    return { assertions: result, warnings };
+}
+// ---------------------------------------------------------------------------
+// Assertion mapping
+// ---------------------------------------------------------------------------
+function mapMCPAssertion(assertion, context, warnings) {
+    switch (assertion.type) {
+        case "tool-called":
+            return buildToolCalledAssertion(assertion, context);
+        case "tool-input-matches":
+            return buildToolInputMatchesAssertion(assertion, context);
+        case "tool-output-matches":
+            return buildToolOutputMatchesAssertion(assertion, context);
+        case "error-returned":
+            return buildErrorReturnedAssertion(assertion, context);
+        case "capability-available":
+            return buildCapabilityAssertion(assertion, context);
+        // Standard assertions — pass through
+        case "contains":
+        case "equals":
+        case "regex":
+        case "is-json":
+        case "llm-rubric":
+        case "javascript":
+        case "python":
+            return {
+                type: assertion.type,
+                ...("value" in assertion ? { value: assertion.value } : {}),
+                ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
+                ...(assertion.type === "llm-rubric" && context.graderProvider
+                    ? { provider: context.graderProvider }
+                    : {}),
+            };
+        default:
+            warnings.push(`MCP task "${context.taskId}": unknown assertion type "${assertion.type}" — passed through`);
+            return {
+                type: assertion.type,
+                ...("value" in assertion ? { value: assertion.value } : {}),
+            };
+    }
+}
+// ---------------------------------------------------------------------------
+// tool-called — asserts the model called a specific tool by name
+// ---------------------------------------------------------------------------
+function buildToolCalledAssertion(assertion, _context) {
+    const toolName = String(assertion.value ?? "");
+    return {
+        type: "javascript",
+        value: buildJsAssertion(`tool-called: ${toolName}`, `
+      const toolCalls = context.vars.__toolCalls || [];
+      const called = toolCalls.some(tc => tc.name === ${JSON.stringify(toolName)});
+      return {
+        pass: called,
+        score: called ? 1 : 0,
+        reason: called
+          ? 'Tool ' + ${JSON.stringify(JSON.stringify(toolName))} + ' was called as expected'
+          : 'Expected tool ' + ${JSON.stringify(JSON.stringify(toolName))} + ' to be called, but it was not. ' +
+            'Tools called: ' + (toolCalls.map(tc => tc.name).join(', ') || 'none'),
+      };`),
+        ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// tool-input-matches — asserts tool call inputs match a schema/value
+// ---------------------------------------------------------------------------
+function buildToolInputMatchesAssertion(assertion, _context) {
+    const expected = assertion.value;
+    const toolName = assertion.toolName ?? assertion.tool;
+    return {
+        type: "javascript",
+        value: buildJsAssertion(`tool-input-matches${toolName ? `: ${toolName}` : ""}`, `
+      const toolCalls = context.vars.__toolCalls || [];
+      const expected = ${JSON.stringify(expected)};
+      const toolFilter = ${JSON.stringify(toolName ?? null)};
+
+      const targetCalls = toolFilter
+        ? toolCalls.filter(tc => tc.name === toolFilter)
+        : toolCalls;
+
+      if (targetCalls.length === 0) {
+        return {
+          pass: false,
+          score: 0,
+          reason: toolFilter
+            ? 'No calls to tool "' + toolFilter + '" found'
+            : 'No tool calls found',
+        };
+      }
+
+      // Check if any call's input matches the expected value
+      const match = targetCalls.some(tc => {
+        const input = tc.input || tc.arguments || {};
+        return Object.entries(expected).every(([k, v]) =>
+          JSON.stringify(input[k]) === JSON.stringify(v)
+        );
+      });
+
+      return {
+        pass: match,
+        score: match ? 1 : 0,
+        reason: match
+          ? 'Tool input matches expected values'
+          : 'Tool input does not match. Expected: ' + JSON.stringify(expected) +
+            ', Got: ' + JSON.stringify(targetCalls.map(tc => tc.input || tc.arguments)),
+      };`),
+        ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// tool-output-matches — asserts tool outputs match expected shape/values
+// ---------------------------------------------------------------------------
+function buildToolOutputMatchesAssertion(assertion, _context) {
+    const expected = assertion.value;
+    const toolName = assertion.toolName ?? assertion.tool;
+    return {
+        type: "javascript",
+        value: buildJsAssertion(`tool-output-matches${toolName ? `: ${toolName}` : ""}`, `
+      const toolCalls = context.vars.__toolCalls || [];
+      const expected = ${JSON.stringify(expected)};
+      const toolFilter = ${JSON.stringify(toolName ?? null)};
+
+      const targetCalls = toolFilter
+        ? toolCalls.filter(tc => tc.name === toolFilter)
+        : toolCalls;
+
+      if (targetCalls.length === 0) {
+        return {
+          pass: false,
+          score: 0,
+          reason: toolFilter
+            ? 'No calls to tool "' + toolFilter + '" found'
+            : 'No tool calls found',
+        };
+      }
+
+      const match = targetCalls.some(tc => {
+        const output = tc.output || tc.result || {};
+        return Object.entries(expected).every(([k, v]) =>
+          JSON.stringify(output[k]) === JSON.stringify(v)
+        );
+      });
+
+      return {
+        pass: match,
+        score: match ? 1 : 0,
+        reason: match
+          ? 'Tool output matches expected values'
+          : 'Tool output does not match. Expected: ' + JSON.stringify(expected),
+      };`),
+        ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// error-returned — asserts the server returned a specific error
+// ---------------------------------------------------------------------------
+function buildErrorReturnedAssertion(assertion, _context) {
+    const expected = assertion.value;
+    return {
+        type: "javascript",
+        value: buildJsAssertion("error-returned", `
+      const toolCalls = context.vars.__toolCalls || [];
+      const expected = ${JSON.stringify(expected ?? {})};
+
+      const errorCall = toolCalls.find(tc => tc.error);
+      if (!errorCall) {
+        return {
+          pass: false,
+          score: 0,
+          reason: 'Expected an error response but no errors were returned',
+        };
+      }
+
+      const error = errorCall.error;
+      let pass = true;
+      const reasons = [];
+
+      if (expected.code !== undefined && error.code !== expected.code) {
+        pass = false;
+        reasons.push('Expected error code ' + expected.code + ', got ' + error.code);
+      }
+
+      if (expected.message !== undefined) {
+        const msgMatch = typeof error.message === 'string' &&
+          error.message.includes(expected.message);
+        if (!msgMatch) {
+          pass = false;
+          reasons.push('Expected error message containing "' + expected.message +
+            '", got "' + (error.message || '') + '"');
+        }
+      }
+
+      if (pass) {
+        reasons.push('Error matches expected pattern');
+      }
+
+      return {
+        pass,
+        score: pass ? 1 : 0,
+        reason: reasons.join('; '),
+      };`),
+        ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// capability-available — asserts the server advertises a capability
+// ---------------------------------------------------------------------------
+function buildCapabilityAssertion(assertion, _context) {
+    const capability = String(assertion.value ?? "");
+    return {
+        type: "javascript",
+        value: buildJsAssertion(`capability-available: ${capability}`, `
+      const capabilities = context.vars.__serverCapabilities || [];
+      const expected = ${JSON.stringify(capability)};
+      const available = capabilities.includes(expected);
+
+      return {
+        pass: available,
+        score: available ? 1 : 0,
+        reason: available
+          ? 'Server advertises capability "' + expected + '"'
+          : 'Server does not advertise capability "' + expected + '". ' +
+            'Available: ' + (capabilities.join(', ') || 'none'),
+      };`),
+        ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Build a Promptfoo-compatible JavaScript assertion string.
+ *
+ * Wraps the assertion body in a function that receives `output` and `context`
+ * from Promptfoo's assertion runner.
+ */
+function buildJsAssertion(label, body) {
+    return `// MCP assertion: ${label}\n(function() {\n${body.trim()}\n})()`;
+}

package/dist/pipeline/compiler/mode-handlers/mcp-server-handler.d.ts

@@ -0,0 +1,67 @@
+/**
+ * MCPServerModeHandler — compilation rules for `mcp-server` evaluation mode.
+ *
+ * This is the first non-literacy mode handler, proving the compiler
+ * architecture works end-to-end. It translates MCP server task definitions
+ * into Promptfoo configuration with:
+ *
+ * - An MCP provider that wraps the server under test
+ * - Tool-call assertions compiled to Promptfoo `javascript` assertions
+ * - Server lifecycle management via Promptfoo provider hooks
+ * - Multi-turn conversation support via Promptfoo's `steps` syntax
+ *
+ * Promptfoo supports MCP servers as providers natively:
+ * ```yaml
+ * providers:
+ *   - id: mcp:./my-server
+ *     config:
+ *       command: node
+ *       args: [./dist/server.js]
+ *       env: { API_KEY: "..." }
+ * ```
+ *
+ * This handler assembles that config from AILF's `MCPServerTaskDefinition`.
+ *
+ * @see docs/exec-plans/architecture-overhaul/phase-3-mcp-server-mode.md
+ * @see packages/core/src/types/eval-mode-config.ts — MCPServerModeConfig
+ * @see packages/core/src/types/generalized-task.ts — MCPServerTaskDefinition
+ */
+import type { MCPServerTaskDefinition, ModeHandler, PromptTemplate } from "../../../_vendor/ailf-core/index.d.ts";
+import type { PromptfooPrompt, PromptfooProvider, PromptfooTestCase } from "../promptfoo-compiler.js";
+export declare const MCP_PROMPT_TEMPLATES: Record<string, PromptTemplate>;
+/** Options for compiling an MCP server task */
+export interface MCPCompileOptions {
+    /** Grader provider for LLM-graded assertions */
+    graderProvider?: string;
+}
+/** Result of compiling a single MCP task */
+export interface MCPCompileResult {
+    /** Promptfoo provider config for the MCP server */
+    providers: PromptfooProvider[];
+    /** Compiled test cases */
+    tests: PromptfooTestCase[];
+    /** Prompts for MCP evaluation */
+    prompts: PromptfooPrompt[];
+    /** Warnings generated during compilation */
+    warnings: string[];
+}
+/** Validation errors for MCP task definitions */
+export interface MCPValidationError {
+    field: string;
+    message: string;
+}
+/**
+ * Validate that an MCP task definition has all required fields.
+ */
+export declare function validateMCPTask(task: MCPServerTaskDefinition): MCPValidationError[];
+/**
+ * Compile an MCP server task definition into Promptfoo configuration.
+ *
+ * This is the core of the MCP mode handler. It produces:
+ * 1. A provider config pointing to the MCP server
+ * 2. Test cases with tool-call assertions
+ * 3. Appropriate prompts for the evaluation
+ */
+export declare function compileMCPTask(task: MCPServerTaskDefinition, options?: MCPCompileOptions): MCPCompileResult;
+/** ModeHandler-conformant export for the mcp-server evaluation mode. */
+export declare const handler: ModeHandler;

package/dist/pipeline/compiler/mode-handlers/mcp-server-handler.js

@@ -0,0 +1,309 @@
+/**
+ * MCPServerModeHandler — compilation rules for `mcp-server` evaluation mode.
+ *
+ * This is the first non-literacy mode handler, proving the compiler
+ * architecture works end-to-end. It translates MCP server task definitions
+ * into Promptfoo configuration with:
+ *
+ * - An MCP provider that wraps the server under test
+ * - Tool-call assertions compiled to Promptfoo `javascript` assertions
+ * - Server lifecycle management via Promptfoo provider hooks
+ * - Multi-turn conversation support via Promptfoo's `steps` syntax
+ *
+ * Promptfoo supports MCP servers as providers natively:
+ * ```yaml
+ * providers:
+ *   - id: mcp:./my-server
+ *     config:
+ *       command: node
+ *       args: [./dist/server.js]
+ *       env: { API_KEY: "..." }
+ * ```
+ *
+ * This handler assembles that config from AILF's `MCPServerTaskDefinition`.
+ *
+ * @see docs/exec-plans/architecture-overhaul/phase-3-mcp-server-mode.md
+ * @see packages/core/src/types/eval-mode-config.ts — MCPServerModeConfig
+ * @see packages/core/src/types/generalized-task.ts — MCPServerTaskDefinition
+ */
+import { buildMCPAssertions, } from "./mcp-assertions.js";
+// ---------------------------------------------------------------------------
+// Canonical MCP server prompt templates
+// ---------------------------------------------------------------------------
+// Handler-owned prompts for MCP server evaluations. Instructs the model to
+// interact with MCP tools rather than writing standalone code.
+export const MCP_PROMPT_TEMPLATES = {
+    "mcp-server": {
+        id: "mcp-server",
+        label: "MCP Server Tool Use",
+        template: `You are an AI assistant with access to an MCP (Model Context Protocol) server that provides tools for interacting with a Sanity content backend.
+
+## Task
+{{task}}
+
+## Instructions
+
+1. Use the available MCP tools to complete the task
+2. Call tools with the correct parameters as described in their schemas
+3. Interpret tool responses and use the results to accomplish the goal
+4. If a tool returns an error, explain the issue clearly
+5. Prefer using specific tools over broad queries when possible
+
+Complete the task using the MCP tools provided:
+`,
+        variables: ["task"],
+    },
+};
+/**
+ * Validate that an MCP task definition has all required fields.
+ */
+export function validateMCPTask(task) {
+    const errors = [];
+    if (!task.id) {
+        errors.push({ field: "id", message: "Task ID is required" });
+    }
+    if (!task.title) {
+        errors.push({ field: "title", message: "Task title is required" });
+    }
+    if (task.serverConfig) {
+        const { transport, command, url } = task.serverConfig;
+        if (transport === "stdio" && !command) {
+            errors.push({
+                field: "serverConfig.command",
+                message: "Server command is required for stdio transport (e.g., 'node dist/server.js')",
+            });
+        }
+        if ((transport === "sse" || transport === "streamable-http") && !url) {
+            errors.push({
+                field: "serverConfig.url",
+                message: `Server URL is required for ${transport} transport`,
+            });
+        }
+    }
+    // Assertions should reference MCP-compatible types
+    if (task.assertions) {
+        for (const assertion of task.assertions) {
+            if (assertion.type === "tool-called" &&
+                !("value" in assertion && assertion.value)) {
+                errors.push({
+                    field: "assertions",
+                    message: 'tool-called assertion requires a "value" specifying the tool name',
+                });
+            }
+        }
+    }
+    return errors;
+}
+// ---------------------------------------------------------------------------
+// Compilation
+// ---------------------------------------------------------------------------
+/**
+ * Compile an MCP server task definition into Promptfoo configuration.
+ *
+ * This is the core of the MCP mode handler. It produces:
+ * 1. A provider config pointing to the MCP server
+ * 2. Test cases with tool-call assertions
+ * 3. Appropriate prompts for the evaluation
+ */
+export function compileMCPTask(task, options) {
+    const warnings = [];
+    // Validate
+    const validationErrors = validateMCPTask(task);
+    if (validationErrors.length > 0) {
+        for (const err of validationErrors) {
+            warnings.push(`MCP task "${task.id}": ${err.field} — ${err.message}`);
+        }
+    }
+    // Build provider
+    const providers = buildMCPProvider(task, warnings);
+    // Build prompts
+    const prompts = buildMCPPrompts(task);
+    // Build test cases
+    const tests = buildMCPTestCases(task, options, warnings);
+    return { providers, tests, prompts, warnings };
+}
+// ---------------------------------------------------------------------------
+// Provider assembly
+// ---------------------------------------------------------------------------
+/**
+ * Build a Promptfoo-native MCP provider config.
+ *
+ * Promptfoo supports MCP servers natively via `id: "mcp"` with a
+ * structured config. See: https://www.promptfoo.dev/docs/providers/mcp/
+ *
+ * Key config shape:
+ *   { enabled: true, server: { url?, command?, args?, name?, auth?, headers? },
+ *     tools?, exclude_tools?, timeout?, debug? }
+ */
+function buildMCPProvider(task, warnings) {
+    const config = task.serverConfig;
+    if (!config) {
+        warnings.push(`MCP task "${task.id}": no serverConfig — using placeholder provider. ` +
+            "Set serverConfig.command or serverConfig.url to point to your MCP server.");
+        return [
+            {
+                id: "mcp",
+                label: `MCP Server: ${task.title}`,
+                config: { enabled: true, server: { name: task.id } },
+            },
+        ];
+    }
+    // Build the server sub-config (Promptfoo's native format)
+    const server = { name: task.id };
+    if (config.transport === "stdio") {
+        // Promptfoo expects command + args as separate fields
+        const parts = config.command?.split(/\s+/) ?? [];
+        server.command = parts[0] ?? "node";
+        if (parts.length > 1) {
+            server.args = parts.slice(1);
+        }
+    }
+    else {
+        // sse or streamable-http — use URL-based connection
+        server.url = config.url;
+    }
+    // Auth config (Promptfoo supports bearer, basic, api_key, oauth)
+    if (config.auth) {
+        server.auth = config.auth;
+    }
+    else if (config.env) {
+        // Backward compat: if env has a token-like variable, convert to
+        // bearer auth using Promptfoo's {{env.VAR}} template syntax
+        const tokenKey = Object.keys(config.env).find((k) => /token|auth|key/i.test(k));
+        if (tokenKey) {
+            const val = config.env[tokenKey];
+            // Convert $env(VAR) syntax to Promptfoo's {{env.VAR}} syntax
+            let envVar = val;
+            if (val.startsWith("$env(") && val.endsWith(")")) {
+                envVar = val.slice(5, -1); // $env(VAR_NAME) → VAR_NAME
+            }
+            // Validate extracted env var name is non-empty and valid
+            if (!envVar || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(envVar)) {
+                warnings.push(`MCP task: env var name "${envVar}" from "${val}" is not a valid ` +
+                    "identifier — skipping auth config");
+            }
+            else {
+                server.auth = {
+                    type: "bearer",
+                    token: `{{env.${envVar}}}`,
+                };
+            }
+        }
+    }
+    // Custom headers (if any non-auth env vars remain)
+    if (config.env) {
+        const headers = {};
+        for (const [key, val] of Object.entries(config.env)) {
+            if (/header[_.]?/i.test(key)) {
+                headers[key.replace(/^header[_.]?/i, "")] = val;
+            }
+        }
+        if (Object.keys(headers).length > 0) {
+            server.headers = headers;
+        }
+    }
+    // Build top-level provider config
+    const providerConfig = {
+        enabled: true,
+        server,
+    };
+    // Tool filtering — map AILF capabilities to Promptfoo tools
+    if (task.capabilities && task.capabilities.length > 0) {
+        providerConfig.tools = task.capabilities;
+    }
+    // Timeout
+    if (config.startupTimeoutMs) {
+        providerConfig.timeout = config.startupTimeoutMs;
+    }
+    return [
+        {
+            id: "mcp",
+            label: `MCP Server: ${task.title}`,
+            config: providerConfig,
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Prompt assembly
+// ---------------------------------------------------------------------------
+function buildMCPPrompts(task) {
+    // MCP mode uses a single prompt — the task description
+    const promptText = task.prompt?.text ??
+        task.prompt?.vars?.task ??
+        task.description ??
+        `Test MCP server: ${task.title}`;
+    return [
+        {
+            id: "mcp-test",
+            label: `MCP: ${task.title}`,
+            raw: String(promptText),
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Test case assembly
+// ---------------------------------------------------------------------------
+function buildMCPTestCases(task, options, warnings) {
+    const tests = [];
+    // Build assertion context
+    const assertionContext = {
+        capabilities: task.capabilities ?? [],
+        graderProvider: options?.graderProvider,
+        taskId: task.id,
+    };
+    // Compile assertions
+    // Cast GeneralizedAssertionDefinition[] → AssertionInput[] (structurally compatible)
+    const assertions = [];
+    if (task.assertions) {
+        const rawAssertions = task.assertions;
+        const { assertions: mapped, warnings: assertionWarnings } = buildMCPAssertions(rawAssertions, assertionContext);
+        assertions.push(...mapped);
+        warnings.push(...assertionWarnings);
+    }
+    // Build test case vars
+    const vars = {
+        task: task.prompt?.vars?.task ?? task.description ?? `Test: ${task.title}`,
+        ...(task.prompt?.vars ?? {}),
+    };
+    // Primary test case
+    tests.push({
+        description: `${task.id} — ${task.title}`,
+        vars,
+        ...(assertions.length > 0 ? { assert: assertions } : {}),
+    });
+    // Multi-turn test cases
+    if (task.multiTurn?.turns && task.multiTurn.turns.length > 0) {
+        tests.push({
+            description: `${task.id} — ${task.title} [multi-turn]`,
+            vars: {
+                ...vars,
+                __multiTurn: task.multiTurn.turns,
+            },
+            ...(assertions.length > 0 ? { assert: assertions } : {}),
+        });
+    }
+    return tests;
+}
+// ---------------------------------------------------------------------------
+// ModeHandler adapter
+// ---------------------------------------------------------------------------
+/** ModeHandler-conformant export for the mcp-server evaluation mode. */
+export const handler = {
+    getPrompts() {
+        return MCP_PROMPT_TEMPLATES;
+    },
+    compileTask(task, ctx) {
+        if (!("mode" in task) || task.mode !== "mcp-server") {
+            throw new Error(`MCP server handler received task with mode "${task.mode ?? "undefined"}" — expected "mcp-server"`);
+        }
+        const result = compileMCPTask(task, {
+            graderProvider: ctx.graderProvider,
+        });
+        return {
+            providers: result.providers,
+            tests: result.tests,
+            prompts: result.prompts,
+            warnings: result.warnings,
+        };
+    },
+};

package/dist/pipeline/compiler/presets/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Presets — bundled evaluation capabilities.
+ *
+ * Each preset packages modes, assertions, rubric templates, fixture
+ * resolvers, prompt templates, scoring profiles, doc fetcher, source
+ * definitions, and feature definitions into a single installable unit.
+ */
+export { createSanityLiteracyPreset, registerSanityLiteracyPreset, sanityLiteracyPreset, } from "./sanity-literacy.js";
+export type { SanityLiteracyPresetOptions } from "./sanity-literacy.js";

package/dist/pipeline/compiler/presets/index.js

@@ -0,0 +1,8 @@
+/**
+ * Presets — bundled evaluation capabilities.
+ *
+ * Each preset packages modes, assertions, rubric templates, fixture
+ * resolvers, prompt templates, scoring profiles, doc fetcher, source
+ * definitions, and feature definitions into a single installable unit.
+ */
+export { createSanityLiteracyPreset, registerSanityLiteracyPreset, sanityLiteracyPreset, } from "./sanity-literacy.js";