@sanity/ailf 1.0.0 → 2.0.1

package/dist/pipeline/compiler/mode-handlers/literacy/prompts.js

@@ -0,0 +1,74 @@
+/**
+ * Canonical prompt templates for literacy-mode evaluations.
+ *
+ * These are the source-of-truth templates. Previously lived in
+ * config/prompts.ts as global templates; now handler-owned so
+ * non-literacy modes can define their own prompts without collision.
+ */
+export const LITERACY_PROMPT_TEMPLATES = {
+    "with-docs": {
+        id: "with-docs",
+        label: "With Documentation",
+        template: `You are an expert Sanity.io developer. Use the following documentation to help implement the task.
+
+## Sanity Documentation
+{{docs}}
+
+## Task
+{{task}}
+
+## Requirements
+
+1. Use ONLY the APIs and patterns shown in the documentation
+2. Provide a complete, working implementation
+3. Include all necessary imports
+4. Follow Sanity best practices as documented
+
+Provide your implementation:
+`,
+        variables: ["docs", "task"],
+    },
+    "without-docs": {
+        id: "without-docs",
+        label: "Baseline (No Docs)",
+        template: `You are an expert Sanity.io developer.
+
+## Task
+{{task}}
+
+## Requirements
+
+1. Provide a complete, working implementation
+2. Include all necessary imports
+3. Follow Sanity best practices
+
+Provide your implementation:
+`,
+        variables: ["task"],
+    },
+    agentic: {
+        id: "agentic",
+        label: "Agentic (self-retrieval)",
+        template: `You are an expert developer helping implement a Sanity.io feature.
+You have access to web search and page fetching tools.
+
+IMPORTANT: Before writing any code, search for and read the relevant
+Sanity.io documentation to ensure you are using the latest APIs and
+best practices. Do not rely on memory alone.
+
+## Task
+{{task}}
+
+## Requirements
+
+1. Search for relevant Sanity documentation before implementing
+2. Use ONLY the APIs and patterns from the current official docs
+3. Provide a complete, working implementation
+4. Include all necessary imports
+5. Follow Sanity best practices as documented
+
+Provide your implementation:
+`,
+        variables: ["task"],
+    },
+};

package/dist/pipeline/compiler/mode-handlers/literacy/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared types for the literacy mode handler.
+ */
+import type { PromptfooPrompt, PromptfooProvider, PromptfooTestCase } from "../../promptfoo-compiler.js";
+/** Options for compiling a literacy task */
+export interface LiteracyCompileOptions {
+    /** Grader provider for LLM-graded assertions */
+    graderProvider?: string;
+    /** Root directory (for resolving file:// doc paths) */
+    rootDir?: string;
+    /** Evaluation sub-mode — controls which entries are generated */
+    evalMode?: import("../../../normalize-mode.js").LiteracyEvalSubMode;
+    /** Model providers to include */
+    models?: {
+        id: string;
+        label: string;
+        config?: Record<string, unknown>;
+    }[];
+    /** Rubric config (templates, weights, profiles) — loaded from rubrics config */
+    rubricConfig?: RubricConfig;
+}
+/** Minimal rubric config needed by the handler */
+export interface RubricConfig {
+    templates: Record<string, {
+        dimension?: string;
+        header: string;
+        scale: string[];
+        criteria_label?: string;
+    }>;
+}
+/** Result of compiling a single literacy task */
+export interface LiteracyCompileResult {
+    /** Promptfoo provider configs */
+    providers: PromptfooProvider[];
+    /** Compiled test cases (gold + optional baseline) */
+    tests: PromptfooTestCase[];
+    /** Prompts for evaluation */
+    prompts: PromptfooPrompt[];
+    /** Warnings generated during compilation */
+    warnings: string[];
+}

package/dist/pipeline/compiler/mode-handlers/literacy/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types for the literacy mode handler.
+ */
+export {};

package/dist/pipeline/compiler/mode-handlers/literacy/validation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Validation for literacy task definitions.
+ */
+import type { LiteracyTaskDefinition } from "../../../../_vendor/ailf-core/index.d.ts";
+export interface LiteracyValidationError {
+    field: string;
+    message: string;
+}
+/**
+ * Validate a literacy task definition.
+ */
+export declare function validateLiteracyTask(task: LiteracyTaskDefinition): LiteracyValidationError[];

package/dist/pipeline/compiler/mode-handlers/literacy/validation.js

@@ -0,0 +1,28 @@
+/**
+ * Validation for literacy task definitions.
+ */
+/**
+ * Validate a literacy task definition.
+ */
+export function validateLiteracyTask(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",
+        });
+    }
+    const promptText = task.prompt?.text ??
+        task.prompt?.template ??
+        task.prompt?.vars?.task ??
+        "";
+    if (!promptText) {
+        errors.push({
+            field: "prompt",
+            message: "Task prompt text is required",
+        });
+    }
+    return errors;
+}

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

@@ -83,18 +83,72 @@ function mapMCPAssertion(assertion, context, warnings) {
 // ---------------------------------------------------------------------------
 function buildToolCalledAssertion(assertion, _context) {
     const toolName = String(assertion.value ?? "");
+    // Strategy: check multiple sources for tool call evidence.
+    // 1. context.vars.__toolCalls (structured, if Promptfoo populates it)
+    // 2. Response metadata toolCallLog (from custom mcp-tool-provider)
+    // 3. Response output text (LLM+MCP providers embed tool_use JSON blocks)
     return {
         type: "javascript",
         value: buildJsAssertion(`tool-called: ${toolName}`, `
-      const toolCalls = context.vars.__toolCalls || [];
-      const called = toolCalls.some(tc => tc.name === ${JSON.stringify(toolName)});
+      var toolName = ${JSON.stringify(toolName)};
+
+      // Strategy 1: structured tool calls from Promptfoo
+      var toolCalls = context.vars.__toolCalls || [];
+      if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+        var called = toolCalls.some(function(tc) { return tc.name === toolName; });
+        return {
+          pass: called,
+          score: called ? 1 : 0,
+          reason: called
+            ? 'Tool "' + toolName + '" was called (via __toolCalls)'
+            : 'Expected tool "' + toolName + '" but found: ' + toolCalls.map(function(tc) { return tc.name; }).join(', '),
+        };
+      }
+
+      // Strategy 2: MCP_TOOLS_CALLED summary appended by custom mcp-tool-provider
+      var outputStr = typeof output === 'string' ? output : JSON.stringify(output || '');
+      var summaryMatch = outputStr.match(/<!-- MCP_TOOLS_CALLED: (\\[.*?\\]) -->/);
+      if (summaryMatch) {
+        try {
+          var calledTools = JSON.parse(summaryMatch[1]);
+          var called = calledTools.includes(toolName);
+          var count = calledTools.filter(function(n) { return n === toolName; }).length;
+          return {
+            pass: called,
+            score: called ? 1 : 0,
+            reason: called
+              ? 'Tool "' + toolName + '" was called ' + count + ' time(s)'
+              : 'Expected tool "' + toolName + '" but found: ' + calledTools.join(', '),
+          };
+        } catch (e) { /* fall through to Strategy 3 */ }
+      }
+
+      // Strategy 3: parse output for tool_use blocks (built-in provider fallback)
+      var outputStr = typeof output === 'string' ? output : JSON.stringify(output || '');
+      var toolUsePattern = /"type"\\s*:\\s*"tool_use"[^}]*"name"\\s*:\\s*"([^"]+)"/g;
+      var foundTools = [];
+      var match;
+      while ((match = toolUsePattern.exec(outputStr)) !== null) {
+        foundTools.push(match[1]);
+      }
+      var fnCallPattern = /"function"\\s*:\\s*\\{[^}]*"name"\\s*:\\s*"([^"]+)"/g;
+      while ((match = fnCallPattern.exec(outputStr)) !== null) {
+        foundTools.push(match[1]);
+      }
+      if (foundTools.length === 0 && outputStr.includes(toolName) && outputStr.includes('tool_use')) {
+        foundTools.push(toolName);
+      }
+
+      var called = foundTools.includes(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'),
+          ? 'Tool "' + toolName + '" was called (detected in output)'
+          : 'Expected tool "' + toolName + '" to be called. ' +
+            (foundTools.length > 0
+              ? 'Tools found in output: ' + foundTools.join(', ')
+              : 'No tool calls detected in output'),
       };`),
         ...(assertion.weight !== undefined ? { weight: assertion.weight } : {}),
     };
@@ -273,5 +327,8 @@ function buildCapabilityAssertion(assertion, _context) {
  * from Promptfoo's assertion runner.
  */
 function buildJsAssertion(label, body) {
-    return `// MCP assertion: ${label}\n(function() {\n${body.trim()}\n})()`;
+    // No IIFE wrapper — Promptfoo wraps the assertion in its own function via
+    // new Function('output', 'context', ...). The body must use `return` at
+    // the top level for the result to reach Promptfoo's validator.
+    return `// MCP assertion: ${label}\n${body.trim()}`;
 }

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

@@ -0,0 +1,42 @@
+/**
+ * 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/archive/exec-plans/architecture-overhaul/phase-3-mcp-server-mode.md
+ */
+import type { PromptfooAssertion } from "../../assertion-mapper.js";
+import type { MCPAssertionContext } from "./types.js";
+/** An AILF assertion definition — accepts both core and generalized types */
+interface AssertionInput {
+    type: string;
+    value?: unknown;
+    weight?: number;
+    /** Allow additional properties from generalized assertions */
+    [key: string]: unknown;
+}
+/**
+ * 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 declare function buildMCPAssertions(assertions: AssertionInput[], context: MCPAssertionContext): {
+    assertions: PromptfooAssertion[];
+    warnings: string[];
+};
+export {};

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

@@ -0,0 +1,334 @@
+/**
+ * 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/archive/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 ?? "");
+    // Strategy: check multiple sources for tool call evidence.
+    // 1. context.vars.__toolCalls (structured, if Promptfoo populates it)
+    // 2. Response metadata toolCallLog (from custom mcp-tool-provider)
+    // 3. Response output text (LLM+MCP providers embed tool_use JSON blocks)
+    return {
+        type: "javascript",
+        value: buildJsAssertion(`tool-called: ${toolName}`, `
+      var toolName = ${JSON.stringify(toolName)};
+
+      // Strategy 1: structured tool calls from Promptfoo
+      var toolCalls = context.vars.__toolCalls || [];
+      if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+        var called = toolCalls.some(function(tc) { return tc.name === toolName; });
+        return {
+          pass: called,
+          score: called ? 1 : 0,
+          reason: called
+            ? 'Tool "' + toolName + '" was called (via __toolCalls)'
+            : 'Expected tool "' + toolName + '" but found: ' + toolCalls.map(function(tc) { return tc.name; }).join(', '),
+        };
+      }
+
+      // Strategy 2: MCP_TOOLS_CALLED summary appended by custom mcp-tool-provider
+      var outputStr = typeof output === 'string' ? output : JSON.stringify(output || '');
+      var summaryMatch = outputStr.match(/<!-- MCP_TOOLS_CALLED: (\\[.*?\\]) -->/);
+      if (summaryMatch) {
+        try {
+          var calledTools = JSON.parse(summaryMatch[1]);
+          var called = calledTools.includes(toolName);
+          var count = calledTools.filter(function(n) { return n === toolName; }).length;
+          return {
+            pass: called,
+            score: called ? 1 : 0,
+            reason: called
+              ? 'Tool "' + toolName + '" was called ' + count + ' time(s)'
+              : 'Expected tool "' + toolName + '" but found: ' + calledTools.join(', '),
+          };
+        } catch (e) { /* fall through to Strategy 3 */ }
+      }
+
+      // Strategy 3: parse output for tool_use blocks (built-in provider fallback)
+      var outputStr = typeof output === 'string' ? output : JSON.stringify(output || '');
+      var toolUsePattern = /"type"\\s*:\\s*"tool_use"[^}]*"name"\\s*:\\s*"([^"]+)"/g;
+      var foundTools = [];
+      var match;
+      while ((match = toolUsePattern.exec(outputStr)) !== null) {
+        foundTools.push(match[1]);
+      }
+      var fnCallPattern = /"function"\\s*:\\s*\\{[^}]*"name"\\s*:\\s*"([^"]+)"/g;
+      while ((match = fnCallPattern.exec(outputStr)) !== null) {
+        foundTools.push(match[1]);
+      }
+      if (foundTools.length === 0 && outputStr.includes(toolName) && outputStr.includes('tool_use')) {
+        foundTools.push(toolName);
+      }
+
+      var called = foundTools.includes(toolName);
+      return {
+        pass: called,
+        score: called ? 1 : 0,
+        reason: called
+          ? 'Tool "' + toolName + '" was called (detected in output)'
+          : 'Expected tool "' + toolName + '" to be called. ' +
+            (foundTools.length > 0
+              ? 'Tools found in output: ' + foundTools.join(', ')
+              : 'No tool calls detected in output'),
+      };`),
+        ...(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) {
+    // No IIFE wrapper — Promptfoo wraps the assertion in its own function via
+    // new Function('output', 'context', ...). The body must use `return` at
+    // the top level for the result to reach Promptfoo's validator.
+    return `// MCP assertion: ${label}\n${body.trim()}`;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * MCP server task compilation — core compiler logic.
+ *
+ * Produces Promptfoo configuration from MCP server task definitions:
+ * 1. A provider config pointing to the MCP server
+ * 2. Test cases with tool-call assertions
+ * 3. Appropriate prompts for the evaluation
+ */
+import type { MCPServerTaskDefinition } from "../../../../_vendor/ailf-core/index.d.ts";
+import type { MCPCompileOptions, MCPCompileResult } from "./types.js";
+/**
+ * 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;