@sanity/ailf 0.5.0 → 2.0.0

package/dist/_vendor/ailf-core/ports/context.d.ts

@@ -11,7 +11,7 @@
  * Fields marked optional are transitional — they will become required
  * as downstream consumers are converted to use them.
  */
-import type { DebugOptions, EvalMode } from "../types/index.js";
+import type { DebugOptions, EvalMode, PluginRegistry } from "../types/index.js";
 import type { CacheStore } from "./cache-store.js";
 import type { DocFetcher } from "./doc-fetcher.js";
 import type { EvalRunner } from "./eval-runner.js";
@@ -27,8 +27,19 @@ import type { TaskSource } from "./task-source.js";
 export interface ResolvedConfig {
     /** Eval package root directory */
     rootDir: string;
-    /** Evaluation mode */
+    /** Evaluation mode — canonical name (e.g., "literacy", "knowledge-probe") */
     mode: EvalMode;
+    /**
+     * Literacy variant — only meaningful when mode is "literacy".
+     *
+     * When a user passes `--mode baseline`, the CLI normalizes this to
+     * `mode: "literacy", variant: "baseline"`. This keeps the pipeline
+     * mode-agnostic while preserving literacy's multi-variant behavior.
+     *
+     * Values: "baseline" | "agentic" | "observed" | "full" | undefined
+     * Undefined means "use the default variant for the mode" (baseline for literacy).
+     */
+    variant?: string;
     /** Debug options */
     debug?: DebugOptions;
     /** Feature area filter */
@@ -129,6 +140,8 @@ export interface ResolvedConfig {
     apiUrl: string;
     /** AILF API key (from AILF_API_KEY env var) */
     apiKey?: string;
+    /** External preset file paths or npm package names to load */
+    presets?: string[];
 }
 /**
  * Application context — the complete dependency carrier.
@@ -153,6 +166,8 @@ export interface AppContext {
     readonly evalRunner: EvalRunner;
     /** Structured logger */
     readonly logger: Logger;
+    /** Plugin registry — mode handlers, assertions, rubric templates, etc. */
+    readonly registry: PluginRegistry;
     /**
      * Persistent report store (Sanity Content Lake).
      * Optional — not all commands need it. Commands that publish or

package/dist/_vendor/ailf-core/ports/doc-fetcher.d.ts

@@ -9,7 +9,7 @@
  * The pipeline orchestrator and all downstream steps work with
  * FetchResult regardless of where the documentation came from.
  */
-import type { TaskDefinition } from "./task-source.js";
+import type { GeneralizedTaskDefinition } from "../types/generalized-task.js";
 /**
  * A fetched documentation context ready for injection into prompts.
  *
@@ -127,5 +127,5 @@ export interface DocFetcher {
      * @param source — Where to fetch documentation from
      * @returns Fetched doc contexts + optional metadata
      */
-    fetch(tasks: TaskDefinition[], source?: DocSourceConfig): Promise<FetchResult>;
+    fetch(tasks: GeneralizedTaskDefinition[], source?: DocSourceConfig): Promise<FetchResult>;
 }

package/dist/_vendor/ailf-core/ports/index.d.ts

@@ -9,7 +9,8 @@ export type { ConfigSource } from "./config-source.js";
 export type { AppContext, ReportSinkPort, ReportStorePort, ResolvedConfig, } from "./context.js";
 export type { DocContext, DocFetcher, DocSourceConfig, DocumentManifestEntry, DocumentOverlaySummary, FetchMetadata, FetchResult, ReleaseImpact, UrlFetchEntry, UrlFetchSummary, } from "./doc-fetcher.js";
 export type { EvalRunConfig, EvalRunner } from "./eval-runner.js";
+export type { CompilationContext, CompileResultAssertion, CompileResultPrompt, CompileResultProvider, CompileResultTestCase, ModeCompileResult, ModeHandler, ModeProviderEntry, ModeRubricConfig, PromptTemplate, } from "./mode-handler.js";
 export type { Logger } from "./logger.js";
 export type { PipelineStep } from "./pipeline-step.js";
-export type { AssertionDefinition, BaselineConfig, CanonicalDocRef, IdDocRef, PathDocRef, PerspectiveDocRef, SlugDocRef, TaskDefinition, TaskSource, TemplatedAssertion, ValueAssertion, } from "./task-source.js";
+export type { TaskSource } from "./task-source.js";
 export { canonicalDocRefLabel, isIdRef, isPathRef, isPerspectiveRef, isSlugRef, isTemplatedAssertion, } from "./task-source.js";

package/dist/_vendor/ailf-core/ports/mode-handler.d.ts

@@ -0,0 +1,129 @@
+/**
+ * ModeHandler — the common interface every evaluation mode implements.
+ *
+ * The pipeline dispatches to mode handlers through the PluginRegistry:
+ *   1. Look up the mode: `ctx.registry.getMode(mode)`
+ *   2. Import the handler module: `import(registration.handlerModule)`
+ *   3. Call: `module.handler.compileTask(task, ctx)`
+ *
+ * Each handler file exports a `handler` object conforming to this interface.
+ * The handler narrows the GeneralizedTaskDefinition to its mode-specific
+ * variant and produces a ModeCompileResult.
+ *
+ * Types here are minimal structural contracts — the eval package's Promptfoo
+ * types satisfy them via TypeScript structural compatibility.
+ *
+ * @see docs/design-docs/architecture-overhaul/extensibility-plugins.md
+ * @see packages/eval/src/pipeline/compiler/mode-handlers/
+ */
+import type { GeneralizedTaskDefinition } from "../types/generalized-task.js";
+/**
+ * A prompt template owned by a mode handler.
+ *
+ * Mode handlers can return these via `getPrompts()` to override the global
+ * config/prompts.ts templates. This lets non-literacy modes define their
+ * own prompt structures without polluting the global config.
+ */
+export interface PromptTemplate {
+    /** Unique identifier (e.g. "with-docs", "agentic") */
+    id: string;
+    /** Human-readable label for display */
+    label: string;
+    /** The prompt template string with {{variable}} placeholders */
+    template: string;
+    /** Variable names used by this template — for documentation only */
+    variables?: string[];
+}
+/** Compilation context — shared state the pipeline provides to every handler */
+export interface CompilationContext {
+    /** Eval package root directory (for resolving file paths) */
+    rootDir: string;
+    /** Grader provider ID for LLM-graded assertions */
+    graderProvider?: string;
+    /** Model providers to include in the evaluation */
+    models?: ModeProviderEntry[];
+    /** Rubric config (templates, weights) — loaded from config/rubrics */
+    rubricConfig?: ModeRubricConfig;
+}
+/** A model provider entry for compilation */
+export interface ModeProviderEntry {
+    id: string;
+    label: string;
+    config?: Record<string, unknown>;
+}
+/** Minimal rubric config needed by mode handlers */
+export interface ModeRubricConfig {
+    templates: Record<string, {
+        dimension?: string;
+        header: string;
+        scale: string[];
+        criteria_label?: string;
+    }>;
+}
+/** A provider entry in the compile result */
+export interface CompileResultProvider {
+    id: string;
+    label?: string;
+    config?: Record<string, unknown>;
+}
+/** A prompt entry in the compile result */
+export interface CompileResultPrompt {
+    id: string;
+    label: string;
+    raw: string;
+}
+/** A test case entry in the compile result */
+export interface CompileResultTestCase {
+    description: string;
+    vars: Record<string, unknown>;
+    assert?: CompileResultAssertion[];
+    prompts?: string[];
+}
+/** An assertion entry in a test case */
+export interface CompileResultAssertion {
+    type: string;
+    value?: unknown;
+    weight?: number;
+    provider?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * ModeCompileResult — the common output every mode handler produces.
+ *
+ * All four fields (providers, tests, prompts, warnings) are present in
+ * every handler's result type. Mode-specific extras (sandbox config,
+ * metadata, extensions) go in the `extras` bag.
+ */
+export interface ModeCompileResult {
+    /** Provider configurations for Promptfoo */
+    providers: CompileResultProvider[];
+    /** Compiled test cases */
+    tests: CompileResultTestCase[];
+    /** Prompt templates */
+    prompts: CompileResultPrompt[];
+    /** Warnings generated during compilation */
+    warnings: string[];
+    /** Mode-specific extras (extensions, sandboxConfig, metadata, etc.) */
+    extras?: Record<string, unknown>;
+}
+/**
+ * ModeHandler — the interface every evaluation mode handler exports.
+ *
+ * Handler modules are referenced by `ModeRegistration.handlerModule` in the
+ * plugin registry. The pipeline imports the module and calls `handler.compileTask()`.
+ *
+ * Each handler file should export:
+ *   export const handler: ModeHandler = { ... }
+ */
+export interface ModeHandler {
+    /** Compile a task definition into evaluation configuration */
+    compileTask(task: GeneralizedTaskDefinition, ctx: CompilationContext): ModeCompileResult;
+    /**
+     * Return prompt templates owned by this mode.
+     *
+     * When defined, the compiler uses these instead of global config/prompts.ts.
+     * Keys are prompt IDs (e.g. "with-docs", "agentic"). Returning undefined
+     * or omitting the method falls back to global prompts.
+     */
+    getPrompts?(): Record<string, PromptTemplate>;
+}

package/dist/_vendor/ailf-core/ports/mode-handler.js

@@ -0,0 +1,19 @@
+/**
+ * ModeHandler — the common interface every evaluation mode implements.
+ *
+ * The pipeline dispatches to mode handlers through the PluginRegistry:
+ *   1. Look up the mode: `ctx.registry.getMode(mode)`
+ *   2. Import the handler module: `import(registration.handlerModule)`
+ *   3. Call: `module.handler.compileTask(task, ctx)`
+ *
+ * Each handler file exports a `handler` object conforming to this interface.
+ * The handler narrows the GeneralizedTaskDefinition to its mode-specific
+ * variant and produces a ModeCompileResult.
+ *
+ * Types here are minimal structural contracts — the eval package's Promptfoo
+ * types satisfy them via TypeScript structural compatibility.
+ *
+ * @see docs/design-docs/architecture-overhaul/extensibility-plugins.md
+ * @see packages/eval/src/pipeline/compiler/mode-handlers/
+ */
+export {};

package/dist/_vendor/ailf-core/ports/task-source.d.ts

@@ -7,150 +7,44 @@
  * - RepoTaskSource (tasks-as-content Phase 4) — reads .ailf/tasks/
  *
  * The key invariant: the pipeline orchestrator and all downstream steps
- * work with TaskDefinition[] regardless of where they came from.
+ * work with GeneralizedTaskDefinition[] regardless of where they came from.
  */
+import type { GeneralizedAssertionDefinition, GeneralizedDocRef, GeneralizedTaskDefinition, GeneralizedTemplatedAssertion, IdDocRef, PathDocRef, PerspectiveDocRef, SlugDocRef } from "../types/generalized-task.js";
 import type { FilterOptions } from "../types/index.js";
-/** A templated assertion referencing a rubric template from config/rubrics.yaml */
-export interface TemplatedAssertion {
-    type: "llm-rubric";
-    template: string;
-    criteria: string[];
-    weight?: number;
-}
-/** A value-based assertion (contains, javascript, etc.) */
-export interface ValueAssertion {
-    type: string;
-    value?: unknown;
-    weight?: number;
-    [key: string]: unknown;
-}
-/** Any assertion definition — either templated or value-based */
-export type AssertionDefinition = TemplatedAssertion | ValueAssertion;
-/** Baseline variant configuration */
-export interface BaselineConfig {
-    /** Whether to generate a baseline variant. Default: true */
-    enabled?: boolean;
-    /** Rubric mode for baseline. Default: "full" */
-    rubric?: "abbreviated" | "full" | "none";
-}
-/**
- * A canonical documentation reference. Each entry resolves docs through
- * one of four strategies, discriminated by key presence (no explicit
- * `type` field). All strategies carry an optional `reason` for context.
- *
- * Strategies:
- * - `slug`        — one article by slug field (legacy, may not be unique)
- * - `path`        — one article by URL path (unique across sections)
- * - `id`          — one document by Sanity `_id` (drafts, imports)
- * - `perspective` — all articles in a content release (one-to-many)
- *
- * @see docs/design-docs/canonical-doc-resolution.md
- */
-export type CanonicalDocRef = SlugDocRef | PathDocRef | IdDocRef | PerspectiveDocRef;
-/** Resolve by article slug field. Legacy — prefer `path` for uniqueness. */
-export interface SlugDocRef {
-    slug: string;
-    reason?: string;
-}
-/** Resolve by URL path (after /docs/). Unique across sections. */
-export interface PathDocRef {
-    path: string;
-    reason?: string;
-}
-/** Resolve by Sanity document `_id`. The primary resolution strategy.
- *
- * Optional `slug` and `path` provide human-readable context — they are
- * NOT used for resolution (the `_id` is authoritative) but help YAML
- * authors understand which document is being referenced. The Content Lake
- * adapter populates them from the dereferenced article.
- */
-export interface IdDocRef {
-    id: string;
-    reason?: string;
-    /** Human-readable slug (informational only — not used for resolution) */
-    slug?: string;
-    /** Human-readable path (informational only — not used for resolution) */
-    path?: string;
-}
-/** Resolve all articles in a content release. One-to-many. */
-export interface PerspectiveDocRef {
-    perspective: string;
-    reason?: string;
-}
-/**
- * A loaded, validated task definition ready for expansion.
- *
- * This is the canonical intermediate representation — adapters produce
- * this from YAML, Content Lake, or .ailf/ files. Downstream consumers
- * (expansion, doc fetching, validation) work exclusively with this type.
- *
- * Design notes:
- * - `taskPrompt` is extracted from `vars.task` in YAML format
- * - `docsPath` is NOT included — it's an infrastructure detail derived
- *   from convention (`file://contexts/canonical/${id}.md`)
- * - `featureArea` is derived by the adapter (filename stem, document
- *   field, directory structure — depends on the source)
- */
-export interface TaskDefinition {
-    /** Unique task identifier */
-    id: string;
-    /** Human-readable description */
-    description: string;
-    /** Feature area this task belongs to */
-    featureArea: string;
-    /** The implementation task prompt (the user-facing request) */
-    taskPrompt: string;
-    /** Canonical doc references with reasons */
-    canonicalDocs: CanonicalDocRef[];
-    /** Path to the reference solution (relative to eval package root) */
-    referenceSolution: string;
-    /** Whether doc coverage rubric should be auto-generated */
-    docCoverage: boolean;
-    /** Assertion definitions (rubric templates + value assertions) */
-    assertions: AssertionDefinition[];
-    /** Baseline variant configuration */
-    baseline?: BaselineConfig;
-    /** Additional template variables beyond task (e.g., custom vars) */
-    extraVars?: Record<string, unknown>;
-    /** Lifecycle status — controls pipeline inclusion. Absent = "active". */
-    status?: "active" | "archived" | "draft" | "paused";
-    /** Freeform labels for filtering and organization */
-    tags?: string[];
-}
-/** Check if a canonical doc ref resolves by slug.
+/** Check if a doc ref resolves by slug.
  *
  * Excludes IdDocRef (which may carry an optional `slug` for display).
  * When both `id` and `slug` are present, it's an IdDocRef, not a SlugDocRef.
  */
-export declare function isSlugRef(ref: CanonicalDocRef): ref is SlugDocRef;
-/** Check if a canonical doc ref resolves by path.
+export declare function isSlugRef(ref: GeneralizedDocRef): ref is SlugDocRef;
+/** Check if a doc ref resolves by path.
  *
  * Excludes IdDocRef (which may carry an optional `path` for display).
  * When both `id` and `path` are present, it's an IdDocRef, not a PathDocRef.
  */
-export declare function isPathRef(ref: CanonicalDocRef): ref is PathDocRef;
-/** Check if a canonical doc ref resolves by document ID.
+export declare function isPathRef(ref: GeneralizedDocRef): ref is PathDocRef;
+/** Check if a doc ref resolves by document ID.
  *
  * Uses `"id" in ref` as the primary discriminator. IdDocRef may also carry
  * optional `slug` and `path` for display purposes, so we cannot exclude
  * on those keys. When both `id` and `slug` are present, `id` wins.
  */
-export declare function isIdRef(ref: CanonicalDocRef): ref is IdDocRef;
-/** Check if a canonical doc ref resolves by content release perspective */
-export declare function isPerspectiveRef(ref: CanonicalDocRef): ref is PerspectiveDocRef;
+export declare function isIdRef(ref: GeneralizedDocRef): ref is IdDocRef;
+/** Check if a doc ref resolves by content release perspective */
+export declare function isPerspectiveRef(ref: GeneralizedDocRef): ref is PerspectiveDocRef;
 /**
- * Extract a display identifier from any canonical doc ref.
+ * Extract a display identifier from any doc ref.
  * Useful for logging, error messages, and retrieval metrics.
  */
-export declare function canonicalDocRefLabel(ref: CanonicalDocRef): string;
+export declare function canonicalDocRefLabel(ref: GeneralizedDocRef): string;
 /** Check if an assertion uses the templated format (template + criteria) */
-export declare function isTemplatedAssertion(entry: AssertionDefinition): entry is TemplatedAssertion;
+export declare function isTemplatedAssertion(entry: GeneralizedAssertionDefinition): entry is GeneralizedTemplatedAssertion;
 /**
  * Port: Where task definitions come from.
  *
  * The pipeline never knows HOW tasks are loaded — it only sees
- * TaskDefinition[]. The adapter handles YAML parsing, GROQ queries,
- * filesystem scanning, etc.
+ * GeneralizedTaskDefinition[]. The adapter handles YAML parsing, GROQ
+ * queries, filesystem scanning, etc.
  */
 export interface TaskSource {
     /**
@@ -159,5 +53,5 @@ export interface TaskSource {
      * @param filter — Area, task ID, or changed-doc filters
      * @returns Validated task definitions ready for expansion
      */
-    loadTasks(filter?: FilterOptions): Promise<TaskDefinition[]>;
+    loadTasks(filter?: FilterOptions): Promise<GeneralizedTaskDefinition[]>;
 }

package/dist/_vendor/ailf-core/ports/task-source.js

@@ -7,12 +7,12 @@
  * - RepoTaskSource (tasks-as-content Phase 4) — reads .ailf/tasks/
  *
  * The key invariant: the pipeline orchestrator and all downstream steps
- * work with TaskDefinition[] regardless of where they came from.
+ * work with GeneralizedTaskDefinition[] regardless of where they came from.
  */
 // ---------------------------------------------------------------------------
-// Type guards — canonical doc refs
+// Type guards — doc refs
 // ---------------------------------------------------------------------------
-/** Check if a canonical doc ref resolves by slug.
+/** Check if a doc ref resolves by slug.
  *
  * Excludes IdDocRef (which may carry an optional `slug` for display).
  * When both `id` and `slug` are present, it's an IdDocRef, not a SlugDocRef.
@@ -20,7 +20,7 @@
 export function isSlugRef(ref) {
     return "slug" in ref && !("id" in ref);
 }
-/** Check if a canonical doc ref resolves by path.
+/** Check if a doc ref resolves by path.
  *
  * Excludes IdDocRef (which may carry an optional `path` for display).
  * When both `id` and `path` are present, it's an IdDocRef, not a PathDocRef.
@@ -28,7 +28,7 @@ export function isSlugRef(ref) {
 export function isPathRef(ref) {
     return "path" in ref && !("id" in ref);
 }
-/** Check if a canonical doc ref resolves by document ID.
+/** Check if a doc ref resolves by document ID.
  *
  * Uses `"id" in ref` as the primary discriminator. IdDocRef may also carry
  * optional `slug` and `path` for display purposes, so we cannot exclude
@@ -37,12 +37,12 @@ export function isPathRef(ref) {
 export function isIdRef(ref) {
     return "id" in ref;
 }
-/** Check if a canonical doc ref resolves by content release perspective */
+/** Check if a doc ref resolves by content release perspective */
 export function isPerspectiveRef(ref) {
     return "perspective" in ref;
 }
 /**
- * Extract a display identifier from any canonical doc ref.
+ * Extract a display identifier from any doc ref.
  * Useful for logging, error messages, and retrieval metrics.
  */
 export function canonicalDocRefLabel(ref) {

package/dist/_vendor/ailf-core/schemas/eval-config.d.ts

@@ -29,10 +29,15 @@ export declare const EvalConfigSchema: z.ZodObject<{
     graderReplications: z.ZodOptional<z.ZodNumber>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        agentic: "agentic";
+        custom: "custom";
+        literacy: "literacy";
+        "mcp-server": "mcp-server";
+        "agent-harness": "agent-harness";
+        "knowledge-probe": "knowledge-probe";
         baseline: "baseline";
-        full: "full";
+        agentic: "agentic";
         observed: "observed";
+        full: "full";
     }>>;
     noAutoScope: z.ZodOptional<z.ZodBoolean>;
     noCache: z.ZodOptional<z.ZodBoolean>;
@@ -52,5 +57,6 @@ export declare const EvalConfigSchema: z.ZodObject<{
     source: z.ZodOptional<z.ZodString>;
     tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type EvalConfig = z.infer<typeof EvalConfigSchema>;

package/dist/_vendor/ailf-core/schemas/eval-config.js

@@ -10,6 +10,7 @@
  * (studio-eval-config) so Content Lake documents validate identically.
  */
 import { z } from "zod";
+import { RAW_EVAL_MODES } from "../../ailf-shared/index.js";
 export const EvalConfigSchema = z
     .object({
     /** Allowed origins for agentic mode */
@@ -46,8 +47,12 @@ export const EvalConfigSchema = z
     graderReplications: z.number().int().positive().optional(),
     /** Custom headers for doc fetching */
     headers: z.record(z.string(), z.string()).optional(),
-    /** Evaluation mode */
-    mode: z.enum(["baseline", "agentic", "observed", "full"]).optional(),
+    /**
+     * Evaluation mode — accepts both canonical and legacy names.
+     * Legacy names ("baseline", "agentic", "observed", "full") must pass
+     * through normalizeMode() before entering typed pipeline code.
+     */
+    mode: z.enum(RAW_EVAL_MODES).optional(),
     /** Disable release-aware auto-scoping */
     noAutoScope: z.boolean().optional(),
     /** Disable local cache */
@@ -76,5 +81,15 @@ export const EvalConfigSchema = z
     tasks: z.array(z.string()).optional(),
     /** Doc source URL overrides */
     urls: z.array(z.string().url()).optional(),
+    /**
+     * External presets to load — file paths or npm package names.
+     *
+     * Each entry is resolved as:
+     *   - Relative path (./foo or ../foo): loaded from disk via jiti
+     *   - Package name: resolved via Node require
+     *
+     * Presets are registered in order after built-in presets.
+     */
+    presets: z.array(z.string()).optional(),
 })
     .strict();

package/dist/_vendor/ailf-core/schemas/pipeline-request.d.ts

@@ -49,10 +49,15 @@ export declare const PipelineRequestSchema: z.ZodObject<{
     inlineTasks: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     jobId: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodEnum<{
-        agentic: "agentic";
+        custom: "custom";
+        literacy: "literacy";
+        "mcp-server": "mcp-server";
+        "agent-harness": "agent-harness";
+        "knowledge-probe": "knowledge-probe";
         baseline: "baseline";
-        full: "full";
+        agentic: "agentic";
         observed: "observed";
+        full: "full";
     }>>;
     noAutoScope: z.ZodOptional<z.ZodBoolean>;
     noCache: z.ZodOptional<z.ZodBoolean>;
@@ -70,12 +75,13 @@ export declare const PipelineRequestSchema: z.ZodObject<{
     source: z.ZodOptional<z.ZodString>;
     sourceReportId: z.ZodOptional<z.ZodString>;
     taskMode: z.ZodOptional<z.ZodEnum<{
+        inline: "inline";
         "content-lake": "content-lake";
         yaml: "yaml";
-        inline: "inline";
     }>>;
     tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /** Inferred TypeScript type for a pipeline request payload. */
 export type PipelineRequest = z.infer<typeof PipelineRequestSchema>;

package/dist/_vendor/ailf-core/schemas/pipeline-request.js

@@ -13,6 +13,7 @@
  * @see packages/eval/src/pipeline/map-request-to-config.ts — maps to ResolvedConfig
  */
 import { z } from "zod";
+import { RAW_EVAL_MODES } from "../../ailf-shared/index.js";
 // ---------------------------------------------------------------------------
 // Debug options — boolean shorthand or structured object
 // ---------------------------------------------------------------------------
@@ -69,7 +70,11 @@ export const PipelineRequestSchema = z.object({
     headers: z.record(z.string(), z.string()).optional(),
     inlineTasks: z.array(z.record(z.string(), z.unknown())).optional(),
     jobId: z.string().optional(),
-    mode: z.enum(["baseline", "agentic", "observed", "full"]).optional(),
+    /**
+     * Evaluation mode — accepts both canonical and legacy names.
+     * Legacy names must pass through normalizeMode() before entering typed pipeline code.
+     */
+    mode: z.enum(RAW_EVAL_MODES).optional(),
     noAutoScope: z.boolean().optional(),
     noCache: z.boolean().optional(),
     noRemoteCache: z.boolean().optional(),
@@ -84,4 +89,6 @@ export const PipelineRequestSchema = z.object({
     taskMode: z.enum(["content-lake", "yaml", "inline"]).optional(),
     tasks: z.array(z.string()).optional(),
     urls: z.array(z.string().url()).optional(),
+    /** External preset file paths or npm package names to load */
+    presets: z.array(z.string()).optional(),
 });