vieval 0.0.4 → 0.0.6

package/dist/core/runner/index.mjs

@@ -1,2 +1,637 @@
-import { a as runScheduledTasks, c as aggregateRunResults, i as RunnerExecutionError, l as createFilesystemTaskCacheRuntime, n as createRunnerSchedule, o as asProjectRelativePath, r as createRunnerRuntimeContext, s as collectEvalEntries, t as createTaskExecutionContext, u as normalizeCacheFilePathSegments } from "../../runner-Dpy-eivM.mjs";
-export { RunnerExecutionError, aggregateRunResults, asProjectRelativePath, collectEvalEntries, createFilesystemTaskCacheRuntime, createRunnerRuntimeContext, createRunnerSchedule, createTaskExecutionContext, normalizeCacheFilePathSegments, runScheduledTasks };
+import { createSchedulerRuntime, getActiveScopes } from "../scheduler/index.mjs";
+import { t as resolveModelByName } from "../../models-DIGdOUpJ.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { errorMessageFrom } from "@moeru/std";
+import { basename, dirname, join, relative } from "node:path";
+import { access, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { Buffer } from "node:buffer";
+import { createReadStream, createWriteStream } from "node:fs";
+import { limitConcurrency } from "@vitest/runner/utils";
+//#region src/core/cache/filesystem.ts
+function sanitizePathSegment(value) {
+	const normalized = value.trim();
+	if (normalized.length === 0) return "default";
+	return normalized.replace(/[^\w.-]+/g, "-");
+}
+function normalizeExtension(extension, mediaType) {
+	if (extension != null && extension.length > 0) return extension.startsWith(".") ? extension.slice(1) : extension;
+	if (mediaType == null || mediaType.length === 0) return;
+	if (mediaType === "application/json") return "json";
+	if (mediaType === "text/plain") return "txt";
+	if (mediaType === "audio/wav") return "wav";
+}
+/**
+* Normalizes cache file options into deterministic relative path segments.
+*
+* Before:
+* - `{ key: ['cases', 'dataset hash', 'v1'], ext: 'json' }`
+*
+* After:
+* - `['cases', 'dataset-hash', 'v1.json']`
+*/
+function normalizeCacheFilePathSegments(options) {
+	const sanitizedKey = options.key.map((segment) => sanitizePathSegment(segment));
+	const extension = normalizeExtension(options.ext, options.mediaType);
+	if (sanitizedKey.length === 0) return extension == null ? ["artifact"] : [`artifact.${extension}`];
+	if (extension == null) return sanitizedKey;
+	const withoutTail = sanitizedKey.slice(0, Math.max(0, sanitizedKey.length - 1));
+	const tail = sanitizedKey[sanitizedKey.length - 1] ?? "artifact";
+	return [...withoutTail, `${tail}.${extension}`];
+}
+async function writeAtomically(path, content) {
+	const directory = dirname(path);
+	const temporaryPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+	await mkdir(directory, { recursive: true });
+	await writeFile(temporaryPath, content);
+	await rename(temporaryPath, path);
+}
+function createCacheFileHandle(path) {
+	return {
+		path,
+		async exists() {
+			try {
+				await access(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		openReadStream() {
+			return createReadStream(path);
+		},
+		async openWriteStream() {
+			await mkdir(dirname(path), { recursive: true });
+			return createWriteStream(path);
+		},
+		async readBuffer() {
+			return await readFile(path);
+		},
+		async writeBuffer(value) {
+			await writeAtomically(path, value);
+		},
+		async readText(encoding = "utf-8") {
+			return await readFile(path, encoding);
+		},
+		async writeText(value, encoding = "utf-8") {
+			await writeAtomically(path, Buffer.from(value, encoding));
+		},
+		async readJson() {
+			return JSON.parse(await readFile(path, "utf-8"));
+		},
+		async writeJson(value) {
+			await writeAtomically(path, `${JSON.stringify(value, null, 2)}\n`);
+		},
+		async loadAsCasesInput() {
+			return await this.readJson();
+		},
+		async loadAsExpectFixture() {
+			return await this.readJson();
+		}
+	};
+}
+function createCacheNamespace(baseDirectory, namespace) {
+	return { file(options) {
+		const relativePathSegments = normalizeCacheFilePathSegments(options);
+		return createCacheFileHandle(join(baseDirectory, sanitizePathSegment(namespace), ...relativePathSegments));
+	} };
+}
+/**
+* Creates a deterministic filesystem-backed task cache runtime.
+*
+* Use when:
+* - eval tasks need reproducible cache paths for expensive pre-processing outputs
+* - benchmark adapters need one artifact-oriented API for text/json/binary reads and writes
+*
+* Expects:
+* - `cacheRootDirectory` to be writable by the running process
+* - `workspaceId` + `projectName` to stay stable for reproducible paths
+*
+* Returns:
+* - task cache runtime that resolves namespaced file handles under:
+*   `<cacheRootDirectory>/<workspaceId>/<projectName>/<namespace>/...`
+*/
+function createFilesystemTaskCacheRuntime(options) {
+	const workspaceDirectory = sanitizePathSegment(options.workspaceId);
+	const projectDirectory = sanitizePathSegment(options.projectName);
+	const baseDirectory = join(options.cacheRootDirectory, workspaceDirectory, projectDirectory);
+	return { namespace(name) {
+		return createCacheNamespace(baseDirectory, name);
+	} };
+}
+//#endregion
+//#region src/core/runner/aggregate.ts
+function cloneScheduledTaskMatrix(matrix) {
+	return {
+		eval: { ...matrix.eval },
+		meta: { ...matrix.meta },
+		run: { ...matrix.run }
+	};
+}
+function assertKnownScoreKind(kind) {
+	if (kind === "exact" || kind === "judge") return kind;
+	throw new TypeError(`Unknown eval score kind "${kind}".`);
+}
+function average(scores) {
+	if (scores.length === 0) return null;
+	return scores.reduce((sum, score) => sum + score, 0) / scores.length;
+}
+function createHybridAverage(exactAverage, judgeAverage) {
+	if (exactAverage != null && judgeAverage != null) return (exactAverage + judgeAverage) / 2;
+	if (exactAverage != null) return exactAverage;
+	if (judgeAverage != null) return judgeAverage;
+	return null;
+}
+function collectScoreBuckets(scores) {
+	const buckets = {
+		exact: [],
+		judge: []
+	};
+	for (const score of scores) {
+		if (assertKnownScoreKind(score.kind) === "exact") {
+			buckets.exact.push(score.score);
+			continue;
+		}
+		buckets.judge.push(score.score);
+	}
+	return buckets;
+}
+function createRunSummary(result) {
+	const buckets = collectScoreBuckets(result.scores);
+	const exactAverage = average(buckets.exact);
+	const judgeAverage = average(buckets.judge);
+	return {
+		entryId: result.entryId,
+		exactAverage,
+		hybridAverage: createHybridAverage(exactAverage, judgeAverage),
+		id: result.id,
+		judgeAverage,
+		matrix: cloneScheduledTaskMatrix(result.matrix),
+		inferenceExecutorId: result.inferenceExecutorId
+	};
+}
+function createProviderSummary(inferenceExecutorId, results) {
+	const exactScores = [];
+	const judgeScores = [];
+	for (const result of results) {
+		const buckets = collectScoreBuckets(result.scores);
+		exactScores.push(...buckets.exact);
+		judgeScores.push(...buckets.judge);
+	}
+	const exactAverage = average(exactScores);
+	const judgeAverage = average(judgeScores);
+	return {
+		exactAverage,
+		hybridAverage: createHybridAverage(exactAverage, judgeAverage),
+		judgeAverage,
+		inferenceExecutorId,
+		runCount: results.length
+	};
+}
+/**
+* Aggregates exact-match and judge-based scores into hybrid runner summaries.
+*
+* Call stack:
+*
+* {@link runScheduledTasks}
+*   -> {@link aggregateRunResults}
+*     -> {@link createRunSummary}
+*     -> {@link createProviderSummary}
+*       -> `report output`
+*
+* Use when:
+* - a runner batch mixes deterministic exact checks with judge-based grading
+* - inferenceExecutor comparison should preserve both score families and one hybrid view
+*
+* Expects:
+* - each score to be normalized to the `0..1` range before aggregation
+* - `scores.kind` to use only `'exact'` or `'judge'`
+*/
+function aggregateRunResults(results) {
+	const runs = results.map(createRunSummary);
+	const inferenceExecutors = Array.from(new Set(results.map((result) => result.inferenceExecutorId))).map((inferenceExecutorId) => {
+		return createProviderSummary(inferenceExecutorId, results.filter((result) => result.inferenceExecutorId === inferenceExecutorId));
+	}).sort((left, right) => left.inferenceExecutorId.localeCompare(right.inferenceExecutorId));
+	const overall = createProviderSummary("overall", results);
+	return {
+		overall: {
+			exactAverage: overall.exactAverage,
+			hybridAverage: overall.hybridAverage,
+			judgeAverage: overall.judgeAverage,
+			runCount: overall.runCount
+		},
+		inferenceExecutors,
+		runs
+	};
+}
+//#endregion
+//#region src/core/runner/collect.ts
+const evalFileSuffix = ".eval.ts";
+const absolutePathPattern = /^(?:[A-Z]:\/|\/|\\\\)/i;
+function normalizePath(value) {
+	return value.replaceAll("\\", "/");
+}
+/**
+* Converts a file path into a project-relative path when possible.
+*
+* Before: `/repo/plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
+* After: `plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
+*
+* Before: `D:/repo/plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
+* After: `D:/repo/plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
+*/
+function asProjectRelativePath(filePath, context) {
+	const normalizedFilePath = normalizePath(filePath);
+	const normalizedProjectRootDirectory = normalizePath(context.projectRootDirectory);
+	const filePathWindowsDrive = normalizedFilePath.match(/^[A-Z]:\//i)?.[0];
+	const projectRootWindowsDrive = normalizedProjectRootDirectory.match(/^[A-Z]:\//i)?.[0];
+	if (filePathWindowsDrive != null && projectRootWindowsDrive == null) return normalizedFilePath;
+	if (filePathWindowsDrive != null && projectRootWindowsDrive != null && filePathWindowsDrive.toLowerCase() !== projectRootWindowsDrive.toLowerCase()) return normalizedFilePath;
+	const projectRootDirectory = context.projectRootDirectory;
+	const relativeFilePath = normalizePath(relative(projectRootDirectory, filePath));
+	if (!absolutePathPattern.test(relativeFilePath)) {
+		if (relativeFilePath === "..") return normalizePath(filePath);
+		if (!relativeFilePath.startsWith("../")) return relativeFilePath;
+	}
+	return normalizePath(filePath);
+}
+function resolveModuleFilePath(moduleHref) {
+	if (!moduleHref.startsWith("file:")) return null;
+	try {
+		return fileURLToPath(moduleHref);
+	} catch {
+		return null;
+	}
+}
+function createCollectedEvalEntry(moduleHref, moduleDefinition, context) {
+	const filePath = resolveModuleFilePath(moduleHref);
+	if (!filePath) return null;
+	const relativeFilePath = asProjectRelativePath(filePath, context);
+	if (!relativeFilePath.endsWith(evalFileSuffix)) return null;
+	const entryName = basename(relativeFilePath, evalFileSuffix);
+	if (entryName.length === 0) return null;
+	const relativeDirectory = dirname(relativeFilePath);
+	const directory = relativeDirectory === "." ? "" : relativeDirectory;
+	return {
+		...moduleDefinition.default,
+		directory,
+		filePath,
+		id: directory.length === 0 ? entryName : `${directory}/${entryName}`,
+		name: entryName
+	};
+}
+/**
+* Collects loaded vieval modules into sorted runner entries with stable ids.
+*
+* Call stack:
+*
+* `import.meta.glob(...)`
+*   -> {@link collectEvalEntries}
+*     -> {@link createCollectedEvalEntry}
+*       -> {@link CollectedEvalEntry}[]
+*
+* Use when:
+* - the runner has already loaded candidate eval modules
+* - downstream scheduling needs stable entry ids and directory metadata
+*/
+function collectEvalEntries(modules, context) {
+	return Object.entries(modules).flatMap(([moduleHref, moduleDefinition]) => {
+		const entry = createCollectedEvalEntry(moduleHref, moduleDefinition, context);
+		if (!entry) return [];
+		return [entry];
+	}).sort((left, right) => left.id.localeCompare(right.id));
+}
+//#endregion
+//#region src/core/runner/run.ts
+function createDefaultExecutionContext(task) {
+	return {
+		cache: { namespace(name) {
+			return { file(options) {
+				const key = options.key.join("/");
+				throw new Error(`Task cache runtime is not configured. Requested namespace "${name}" and key "${key}".`);
+			} };
+		} },
+		model(options) {
+			const requestedModelName = typeof options === "string" ? options : options?.name;
+			if (requestedModelName != null) throw new Error(`No model registry configured. Requested model: ${requestedModelName}`);
+			throw new Error(`No model registry configured for task inferenceExecutor id "${task.inferenceExecutor.id}".`);
+		}
+	};
+}
+/**
+* Error thrown when a scheduled run fails before producing a normalized result.
+*/
+var RunnerExecutionError = class extends Error {
+	/**
+	* Stable task id that failed.
+	*/
+	taskId;
+	constructor(taskId, cause) {
+		const message = errorMessageFrom(cause) ?? "Unknown runner execution failure.";
+		super(`Runner task "${taskId}" failed: ${message}`);
+		this.name = "RunnerExecutionError";
+		this.taskId = taskId;
+		this.cause = cause;
+	}
+};
+function createRunnerExecutionError(taskId, cause) {
+	if (cause instanceof RunnerExecutionError && cause.taskId === taskId) return cause;
+	return new RunnerExecutionError(taskId, cause);
+}
+/**
+* Executes runner tasks sequentially and aggregates the normalized results.
+*
+* Call stack:
+*
+* {@link createRunnerSchedule}
+*   -> {@link runScheduledTasks}
+*     -> `executor(task)`
+*       -> {@link aggregateRunResults}
+*
+* Use when:
+* - the caller already expanded the runner matrix
+* - task execution should stay deterministic and easy to debug
+*
+* Expects:
+* - `executor` to return normalized `0..1` scores
+* - callers to handle concurrency outside this helper when needed
+* - `onTaskStart` / `onTaskEnd` hooks to be synchronous lifecycle observers
+*
+* Throws:
+* - `RunnerExecutionError` when task setup, hooks, or the executor throws
+*/
+async function runScheduledTasks(tasks, executor, options = {}) {
+	if (tasks.length === 0) return aggregateRunResults([]);
+	async function executeScheduledTask(task) {
+		let executionContext;
+		try {
+			executionContext = options.createExecutionContext?.(task) ?? createDefaultExecutionContext(task);
+		} catch (error) {
+			throw createRunnerExecutionError(task.id, error);
+		}
+		try {
+			options.onTaskStart?.(task);
+		} catch (error) {
+			throw createRunnerExecutionError(task.id, error);
+		}
+		let runResult;
+		try {
+			runResult = await executor(task, executionContext);
+		} catch (error) {
+			try {
+				options.onTaskEnd?.(task, "failed");
+			} catch {}
+			throw createRunnerExecutionError(task.id, error);
+		}
+		try {
+			options.onTaskEnd?.(task, "passed");
+		} catch (error) {
+			throw createRunnerExecutionError(task.id, error);
+		}
+		return runResult;
+	}
+	const maxConcurrency = options.maxConcurrency ?? 1;
+	if (maxConcurrency <= 1) {
+		const results = [];
+		for (const task of tasks) results.push(await executeScheduledTask(task));
+		return aggregateRunResults(results);
+	}
+	const runWithLimit = limitConcurrency(maxConcurrency);
+	return aggregateRunResults((await Promise.all(tasks.map(async (task, index) => {
+		return {
+			index,
+			result: await runWithLimit(async () => executeScheduledTask(task))
+		};
+	}))).sort((left, right) => left.index - right.index).map((item) => item.result));
+}
+//#endregion
+//#region src/core/runner/runtime-context.ts
+const require = createRequire(import.meta.url);
+/**
+* Creates a side-effect-free runtime context for runner path normalization.
+*
+* Call stack:
+*
+* {@link createRunnerRuntimeContext}
+*   -> `findWorkspaceDir(cwd)`
+*     -> `resolve projectRootDirectory`
+*       -> `{ projectRootDirectory }`
+*
+* Use when:
+* - initializing runner infrastructure before collecting eval modules
+* - tests need deterministic root resolution behavior
+*/
+async function createRunnerRuntimeContext(options = {}) {
+	const cwd = options.cwd ?? dirname(fileURLToPath(import.meta.url));
+	const fallbackProjectRootDirectory = options.fallbackProjectRootDirectory ?? fileURLToPath(new URL("../../../", import.meta.url));
+	const { findWorkspaceDir } = require("@pnpm/find-workspace-dir");
+	return { projectRootDirectory: await findWorkspaceDir(cwd) ?? fallbackProjectRootDirectory };
+}
+//#endregion
+//#region src/core/runner/schedule.ts
+const matrixLayerKeys = new Set([
+	"disable",
+	"extend",
+	"override"
+]);
+const ambiguousMatrixDefinitionErrorMessage = "Ambiguous matrix definition: cannot mix reserved layer keys (disable, extend, override) with matrix axis keys.";
+function encodeTaskIdSegment(value) {
+	return encodeURIComponent(value);
+}
+function stringifyMatrixValue(value) {
+	return String(value);
+}
+function cloneMatrixSelection(matrix) {
+	return { ...matrix };
+}
+function createScheduledTaskMatrix(runMatrix, evalMatrix) {
+	return {
+		eval: cloneMatrixSelection(evalMatrix),
+		meta: {
+			evalRowId: createStableRowId(evalMatrix),
+			runRowId: createStableRowId(runMatrix)
+		},
+		run: cloneMatrixSelection(runMatrix)
+	};
+}
+function isMatrixLayer(matrix) {
+	const matrixKeys = Object.keys(matrix);
+	return matrixKeys.length > 0 && matrixKeys.every((key) => matrixLayerKeys.has(key));
+}
+function assertNonAmbiguousMatrixDefinition(matrix) {
+	const matrixKeys = Object.keys(matrix);
+	const hasReservedKeys = matrixKeys.some((key) => matrixLayerKeys.has(key));
+	const hasAxisKeys = matrixKeys.some((key) => !matrixLayerKeys.has(key));
+	if (hasReservedKeys && hasAxisKeys) throw new TypeError(ambiguousMatrixDefinitionErrorMessage);
+}
+function normalizeLayerInputToAxes(matrix) {
+	if (matrix == null) return;
+	assertNonAmbiguousMatrixDefinition(matrix);
+	if (isMatrixLayer(matrix)) return matrix;
+	return { extend: matrix };
+}
+function dedupeAxisValues(values) {
+	return Array.from(new Set(values.map(stringifyMatrixValue)));
+}
+function applyAxisValues(axes, definition, mode) {
+	if (definition == null) return;
+	for (const [axis, values] of Object.entries(definition)) {
+		const nextValues = dedupeAxisValues(values);
+		if (mode === "extend") {
+			const existingValues = axes.get(axis) ?? [];
+			axes.set(axis, Array.from(new Set([...existingValues, ...nextValues])));
+			continue;
+		}
+		axes.set(axis, nextValues);
+	}
+}
+function applyLayer(baseAxes, layer) {
+	const nextAxes = new Map(Array.from(baseAxes.entries()).map(([axis, values]) => [axis, [...values]]));
+	for (const axis of layer?.disable ?? []) nextAxes.delete(axis);
+	applyAxisValues(nextAxes, layer?.extend, "extend");
+	applyAxisValues(nextAxes, layer?.override, "override");
+	return nextAxes;
+}
+function expandAxesToRows(axes) {
+	if (axes.size === 0) return [{}];
+	const dimensions = Array.from(axes.entries());
+	let selections = [{}];
+	for (const [axis, values] of dimensions) {
+		if (values.length === 0) return [];
+		const nextSelections = [];
+		for (const selection of selections) for (const value of values) nextSelections.push({
+			...selection,
+			[axis]: value
+		});
+		selections = nextSelections;
+	}
+	return selections;
+}
+function createStableRowId(matrix) {
+	const segments = Object.entries(matrix).sort(([leftAxis], [rightAxis]) => leftAxis.localeCompare(rightAxis)).map(([axis, value]) => `${encodeTaskIdSegment(axis)}=${encodeTaskIdSegment(value)}`);
+	if (segments.length === 0) return "default";
+	return segments.join("&");
+}
+function createTaskId(entryId, inferenceExecutorId, runRowId, evalRowId) {
+	return [
+		encodeTaskIdSegment(entryId),
+		encodeTaskIdSegment(inferenceExecutorId),
+		`run=${encodeTaskIdSegment(runRowId)}`,
+		`eval=${encodeTaskIdSegment(evalRowId)}`
+	].join("::");
+}
+function createResolvedRunAxes(entry, runMatrix) {
+	let resolvedAxes = /* @__PURE__ */ new Map();
+	for (const layerInput of [
+		runMatrix,
+		entry.matrix?.runMatrix,
+		entry.task?.matrix?.runMatrix
+	]) resolvedAxes = applyLayer(resolvedAxes, normalizeLayerInputToAxes(layerInput));
+	return resolvedAxes;
+}
+function createResolvedEvalAxes(entry, evalMatrix) {
+	let resolvedAxes = /* @__PURE__ */ new Map();
+	for (const layerInput of [
+		evalMatrix,
+		entry.matrix?.evalMatrix,
+		entry.task?.matrix?.evalMatrix
+	]) resolvedAxes = applyLayer(resolvedAxes, normalizeLayerInputToAxes(layerInput));
+	return resolvedAxes;
+}
+/**
+* Expands collected entries into a stable runner schedule.
+*
+* Call stack:
+*
+* {@link collectEvalEntries} (`../runner`)
+*   -> {@link createRunnerSchedule}
+*     -> {@link expandAxesToRows}
+*       -> {@link ScheduledTask}[]
+*
+* Use when:
+* - the runner already knows which eval entries are available
+* - each entry must run against multiple inferenceExecutors or matrix variants
+*
+* Expects:
+* - `entries` and `inferenceExecutors` to be provided in the desired execution order
+* - matrix axes to use insertion order when generating combinations
+*/
+function createRunnerSchedule(options) {
+	if (options.entries.length === 0) return [];
+	if (options.inferenceExecutors.length === 0) return [];
+	const tasks = [];
+	for (const entry of options.entries) {
+		const runSelections = expandAxesToRows(createResolvedRunAxes(entry, options.runMatrix));
+		const evalSelections = expandAxesToRows(createResolvedEvalAxes(entry, options.evalMatrix));
+		if (runSelections.length === 0 || evalSelections.length === 0) continue;
+		for (const inferenceExecutor of options.inferenceExecutors) for (const runMatrix of runSelections) for (const evalMatrix of evalSelections) {
+			const isolatedMatrix = createScheduledTaskMatrix(runMatrix, evalMatrix);
+			tasks.push({
+				entry,
+				id: createTaskId(entry.id, inferenceExecutor.id, isolatedMatrix.meta.runRowId, isolatedMatrix.meta.evalRowId),
+				matrix: isolatedMatrix,
+				inferenceExecutor
+			});
+		}
+	}
+	return tasks;
+}
+//#endregion
+//#region src/core/runner/task-context.ts
+function createNoopTaskCacheRuntime() {
+	return { namespace(name) {
+		return { file(options) {
+			const key = options.key.join("/");
+			throw new Error(`Task cache runtime is not configured. Requested namespace "${name}" and key "${key}".`);
+		} };
+	} };
+}
+function resolveDefaultTaskModel(models, task) {
+	const runMatrixModelName = task.matrix.run.model;
+	if (runMatrixModelName != null) {
+		const matrixSelectedModel = resolveModelByName(models, runMatrixModelName);
+		if (matrixSelectedModel != null) return matrixSelectedModel;
+		throw new Error(`Unknown configured model "${runMatrixModelName}" from task.matrix.run.model.`);
+	}
+	const matched = resolveModelByName(models, task.inferenceExecutor.id);
+	if (matched != null) return matched;
+	if (models.length > 1) throw new Error([
+		`Multiple configured models are available, but no default model is selected for inferenceExecutor "${task.inferenceExecutor.id}".`,
+		"Select one model explicitly by either:",
+		"- setting runMatrix.override.model (or task matrix run.model)",
+		"- setting project.inferenceExecutors to a matching model id",
+		"- calling context.model({ name: \"your-model-id-or-alias\" })"
+	].join("\n"));
+	if (models.length === 1) {
+		const firstModel = models[0];
+		if (firstModel != null) return firstModel;
+	}
+	throw new Error(`No configured model found for inferenceExecutor id "${task.inferenceExecutor.id}".`);
+}
+/**
+* Creates task-scoped model resolver context for runner execution.
+*
+* Call stack:
+*
+* {@link runScheduledTasks}
+*   -> {@link createTaskExecutionContext}
+*     -> {@link resolveModelByName}
+*       -> `task.model()` / `task.model({ name })`
+*/
+function createTaskExecutionContext(options) {
+	return {
+		cache: options.cache ?? createNoopTaskCacheRuntime(),
+		model(selection) {
+			if (selection == null) return resolveDefaultTaskModel(options.models, options.task);
+			const name = typeof selection === "string" ? selection : selection.name;
+			const namedModel = resolveModelByName(options.models, name);
+			if (namedModel == null) throw new Error(`Unknown configured model "${name}".`);
+			return namedModel;
+		}
+	};
+}
+//#endregion
+export { RunnerExecutionError, aggregateRunResults, asProjectRelativePath, collectEvalEntries, createFilesystemTaskCacheRuntime, createRunnerRuntimeContext, createRunnerSchedule, createSchedulerRuntime, createTaskExecutionContext, getActiveScopes, normalizeCacheFilePathSegments, runScheduledTasks };
+
+//# sourceMappingURL=index.mjs.map