anpord 0.1.13 → 0.1.16

package/dist/runtime-YVJP5P2r.cjs

@@ -0,0 +1,292 @@
+const require_eval_validations = require("./eval-validations-CqMUt5ra.cjs");
+const require_api_mocks = require("./api-mocks-B3qngoqS.cjs");
+let effect = require("effect");
+let _effect_platform = require("@effect/platform");
+let _effect_platform_node_NodeFileSystem = require("@effect/platform-node/NodeFileSystem");
+let _effect_platform_node_NodeRuntime = require("@effect/platform-node/NodeRuntime");
+let node_http = require("node:http");
+let _effect_platform_node_NodeHttpServer = require("@effect/platform-node/NodeHttpServer");
+//#region src/mock-api/define.ts
+const endpoint = (definition) => definition;
+const Name = effect.Schema.String.pipe(effect.Schema.pattern(/^[a-z][a-z0-9-]{0,63}$/));
+const Path = effect.Schema.String.pipe(effect.Schema.pattern(/^\/(?:[A-Za-z0-9._~-]+|:[A-Za-z][A-Za-z0-9_]*)(?:\/(?:[A-Za-z0-9._~-]+|:[A-Za-z][A-Za-z0-9_]*))*\/?$|^\/$/));
+const PARAMETER = /:[A-Za-z][A-Za-z0-9_]*/g;
+const api = (definition) => {
+	effect.Schema.decodeUnknownSync(Name)(definition.name);
+	const routes = /* @__PURE__ */ new Set();
+	for (const route of definition.endpoints) {
+		effect.Schema.decodeUnknownSync(Path)(route.path);
+		const key = `${route.method} ${route.path.replace(PARAMETER, ":parameter")}`;
+		if (routes.has(key)) throw new Error(`Duplicate API endpoint: ${key}`);
+		routes.add(key);
+		if (Object.keys(route.responses).length === 0) throw new Error(`API endpoint needs response schemas: ${key}`);
+		for (const status of Object.keys(route.responses)) effect.Schema.decodeUnknownSync(effect.Schema.Int.pipe(effect.Schema.between(200, 599)))(Number(status));
+	}
+	return definition;
+};
+//#endregion
+//#region src/mock-api/errors.ts
+var ApiMockError = class extends effect.Data.TaggedError("ApiMockError") {};
+var ApiRequestError = class extends effect.Data.TaggedError("ApiRequestError") {};
+//#endregion
+//#region src/mock-api/capture.ts
+const SECRET_KEYS = [
+	"authorization",
+	"proxy-authorization",
+	"cookie",
+	"set-cookie",
+	"api-key",
+	"x-api-key",
+	"token",
+	"password",
+	"secret"
+];
+const apiCapture = (keys = []) => {
+	const sensitive = new Set([...SECRET_KEYS, ...keys].map((key) => key.toLowerCase()));
+	const capture = require_eval_validations.validationCapture();
+	return (value) => {
+		try {
+			const text = JSON.stringify(value, (key, current) => sensitive.has(key.toLowerCase()) ? "[redacted]" : current);
+			return capture(text === void 0 ? null : JSON.parse(text));
+		} catch {
+			return require_eval_validations.unavailableValue;
+		}
+	};
+};
+//#endregion
+//#region src/mock-api/standard-schema.ts
+const decodeStandard = (schema, value) => effect.Effect.tryPromise({
+	try: async () => {
+		const result = await schema["~standard"].validate(value);
+		if (result.issues !== void 0) throw new Error(result.issues.map(({ message }) => message).join("; "));
+		return result.value;
+	},
+	catch: () => new ApiMockError({ message: "Value does not match the declared schema" })
+});
+//#endregion
+//#region src/mock-api/response.ts
+const HeaderName = effect.Schema.String.pipe(effect.Schema.pattern(/^[!#$%&'*+.^_`|~A-Za-z0-9-]+$/), effect.Schema.filter((name) => ![
+	"content-length",
+	"transfer-encoding",
+	"content-type"
+].includes(name.toLowerCase())));
+const Response = effect.Schema.Struct({
+	status: effect.Schema.Int,
+	body: effect.Schema.Unknown,
+	headers: effect.Schema.optional(effect.Schema.Record({
+		key: HeaderName,
+		value: effect.Schema.String.pipe(effect.Schema.pattern(/^[\t\x20-\x7e\x80-\xff]*$/))
+	}))
+});
+const bodyless = (status) => [
+	204,
+	205,
+	304
+].includes(status);
+const endpointResponse = (route, input, log) => effect.Effect.gen(function* () {
+	const decoded = yield* decodeStandard(route.inputSchema, input).pipe(effect.Effect.mapError(() => new ApiRequestError({
+		status: 400,
+		message: "Request does not match the endpoint schema"
+	})));
+	const returned = yield* effect.Effect.tryPromise({
+		try: (signal) => Promise.resolve(route.handler(decoded, {
+			signal,
+			log
+		})),
+		catch: () => new ApiMockError({ message: "Endpoint handler threw" })
+	}).pipe(effect.Effect.timeoutFail({
+		duration: "30 seconds",
+		onTimeout: () => new ApiMockError({ message: "Endpoint handler timed out" })
+	}));
+	const response = yield* effect.Schema.decodeUnknown(Response)(returned).pipe(effect.Effect.mapError(() => new ApiMockError({ message: "Invalid endpoint response" })));
+	const schema = route.responses[response.status];
+	if (schema === void 0) return yield* new ApiMockError({ message: "Endpoint returned an undeclared status" });
+	const output = yield* decodeStandard(schema, response.body);
+	if (bodyless(response.status) && output !== null) return yield* new ApiMockError({ message: "This HTTP status cannot carry a response body" });
+	const body = yield* effect.Effect.try({
+		try: () => {
+			const text = JSON.stringify(output);
+			if (text === void 0) throw new Error("Response body is undefined");
+			return text;
+		},
+		catch: () => new ApiMockError({ message: "Response is not JSON serializable" })
+	});
+	return {
+		...response,
+		body,
+		error: null
+	};
+});
+//#endregion
+//#region src/mock-api/handler.ts
+const Json = effect.Schema.parseJson(effect.Schema.Unknown);
+const JSON_CONTENT_TYPE = /^application\/(?:[a-z0-9!#$&^_.+-]+\+)?json$/i;
+const requestHandler = (definition, route, sequence, record) => effect.Effect.gen(function* () {
+	const request = yield* _effect_platform.HttpServerRequest.HttpServerRequest;
+	const routeContext = yield* effect.Effect.serviceOption(_effect_platform.HttpRouter.RouteContext);
+	const params = effect.Option.isSome(routeContext) ? routeContext.value.params : {};
+	const index = yield* effect.Ref.getAndUpdate(sequence, (value) => value + 1);
+	const startedAt = yield* effect.Clock.currentTimeMillis;
+	const url = new URL(request.url, "http://localhost");
+	const capture = apiCapture(definition.redact);
+	const captureLog = apiCapture(definition.redact);
+	const logs = [];
+	const fields = {
+		params,
+		query: _effect_platform.HttpServerRequest.searchParamsFromURL(url),
+		headers: request.headers
+	};
+	let input = fields;
+	const save = (status, output, error) => effect.Effect.gen(function* () {
+		const finishedAt = yield* effect.Clock.currentTimeMillis;
+		yield* record({
+			api: definition.name,
+			index,
+			method: request.method,
+			path: url.pathname,
+			matched: route !== void 0,
+			startedAt,
+			durationMs: Math.max(0, Math.round(finishedAt - startedAt)),
+			input: capture(input),
+			output: capture(output),
+			status,
+			error,
+			logs
+		});
+	}).pipe(effect.Effect.uninterruptible);
+	const { status, headers, body, error } = yield* effect.Effect.gen(function* () {
+		if (route === void 0) return yield* new ApiRequestError({
+			status: 404,
+			message: "No mock endpoint matches this request"
+		});
+		const text = yield* request.text.pipe(effect.Effect.mapError(() => new ApiRequestError({
+			status: 413,
+			message: "Request body could not be read within the size limit"
+		})));
+		if (text && !JSON_CONTENT_TYPE.test(request.headers["content-type"]?.split(";")[0]?.trim() ?? "")) return yield* new ApiRequestError({
+			status: 415,
+			message: "Expected a JSON request body"
+		});
+		const body = text === "" ? null : yield* effect.Schema.decodeUnknown(Json)(text).pipe(effect.Effect.mapError(() => new ApiRequestError({
+			status: 400,
+			message: "Invalid JSON request body"
+		})));
+		input = {
+			...fields,
+			body
+		};
+		return yield* endpointResponse(route, input, (value) => {
+			if (logs.length < 64) logs.push(captureLog(value));
+		});
+	}).pipe(effect.Effect.catchTags({
+		ApiRequestError: ({ status, message }) => effect.Effect.succeed({
+			status,
+			body: JSON.stringify({ message }),
+			headers: void 0,
+			error: null
+		}),
+		ApiMockError: ({ message }) => effect.Effect.succeed({
+			status: 500,
+			body: JSON.stringify({ message }),
+			headers: void 0,
+			error: message
+		})
+	}), effect.Effect.onInterrupt(() => save(499, null, "Request cancelled").pipe(effect.Effect.orDie)));
+	const empty = request.method === "HEAD" || bodyless(status);
+	yield* save(status, {
+		status,
+		headers,
+		body: empty ? null : JSON.parse(body)
+	}, error);
+	return empty ? _effect_platform.HttpServerResponse.empty({
+		status,
+		headers
+	}) : _effect_platform.HttpServerResponse.text(body, {
+		status,
+		headers,
+		contentType: "application/json"
+	});
+}).pipe(_effect_platform.HttpServerRequest.withMaxBodySize(effect.Option.some(1048576)), effect.Effect.withSpan("ApiMock.request"));
+//#endregion
+//#region src/mock-api/server.ts
+const startApi = (definition, record) => effect.Effect.gen(function* () {
+	yield* effect.Effect.try({
+		try: () => api(definition),
+		catch: () => new ApiMockError({ message: "Invalid API definition" })
+	});
+	const sequence = yield* effect.Ref.make(0);
+	let router = _effect_platform.HttpRouter.empty;
+	for (const route of definition.endpoints) router = _effect_platform.HttpRouter.route(route.method)(router, route.path, requestHandler(definition, route, sequence, record));
+	const server = yield* (0, _effect_platform_node_NodeHttpServer.make)(node_http.createServer, {
+		host: "127.0.0.1",
+		port: 0
+	}).pipe(effect.Effect.mapError(() => new ApiMockError({ message: "Could not start local API server" })));
+	yield* server.serve(router.pipe(effect.Effect.catchTag("RouteNotFound", () => requestHandler(definition, void 0, sequence, record))));
+	if (server.address._tag !== "TcpAddress") return yield* new ApiMockError({ message: "API server did not bind TCP" });
+	return {
+		name: definition.name,
+		url: `http://127.0.0.1:${server.address.port}`,
+		endpoints: definition.endpoints.map(({ method, path, description }) => ({
+			method,
+			path,
+			...description ? { description } : {}
+		}))
+	};
+}).pipe(effect.Effect.withSpan("ApiMock.start"));
+//#endregion
+//#region src/mock-api/runtime.ts
+const withApi = ({ api, run }) => effect.Effect.gen(function* () {
+	const calls = yield* effect.Ref.make([]);
+	const fatal = yield* effect.Deferred.make();
+	const server = yield* startApi(api, (call) => effect.Ref.modify(calls, (values) => [values.length < 256, values.length < 256 ? [...values, call] : values]).pipe(effect.Effect.flatMap((recorded) => recorded ? effect.Effect.void : effect.Deferred.fail(fatal, new ApiMockError({ message: "API request limit exceeded" })).pipe(effect.Effect.asVoid))));
+	const result = yield* effect.Effect.tryPromise({
+		try: () => run({
+			url: server.url,
+			calls: () => effect.Effect.runPromise(effect.Ref.get(calls))
+		}),
+		catch: (cause) => cause
+	}).pipe(effect.Effect.raceFirst(effect.Deferred.await(fatal)));
+	if ((yield* effect.Ref.get(calls)).some((call) => call.error !== null)) return yield* new ApiMockError({ message: "An API endpoint failed during execution" });
+	return result;
+}).pipe(effect.Effect.scoped, effect.Effect.withSpan("ApiMock.withApi"), effect.Effect.runPromise);
+const runApiServers = (definitions) => effect.Effect.gen(function* () {
+	const fs = yield* _effect_platform.FileSystem.FileSystem;
+	const fatal = yield* effect.Deferred.make();
+	yield* fs.makeDirectory(".anpord/api", { recursive: true });
+	yield* fs.writeFileString(require_api_mocks.API_JOURNAL, "");
+	const lock = yield* effect.Effect.makeSemaphore(1);
+	const count = yield* effect.Ref.make(0);
+	const record = (call) => effect.Effect.gen(function* () {
+		if ((yield* effect.Ref.getAndUpdate(count, (value) => value + 1)) >= 256) return yield* new ApiMockError({ message: "API request limit exceeded" });
+		yield* fs.writeFileString(require_api_mocks.API_JOURNAL, `${JSON.stringify(call)}\n`, { flag: "a" });
+	}).pipe(effect.Effect.mapError(() => new ApiMockError({ message: "API request evidence could not be written" })), effect.Effect.tapError((cause) => effect.Deferred.fail(fatal, cause)), lock.withPermits(1));
+	const manifest = yield* effect.Effect.forEach(definitions, (definition) => startApi(definition, record));
+	yield* fs.writeFileString(require_api_mocks.API_MANIFEST, JSON.stringify(manifest));
+	yield* effect.Effect.sync(() => process.stdout.write(`${require_api_mocks.API_READY}${JSON.stringify(manifest)}\n`));
+	yield* effect.Deferred.await(fatal);
+}).pipe(effect.Effect.scoped, effect.Effect.provide(_effect_platform_node_NodeFileSystem.layer), effect.Effect.withSpan("ApiMock.serve"), _effect_platform_node_NodeRuntime.runMain);
+//#endregion
+Object.defineProperty(exports, "api", {
+	enumerable: true,
+	get: function() {
+		return api;
+	}
+});
+Object.defineProperty(exports, "endpoint", {
+	enumerable: true,
+	get: function() {
+		return endpoint;
+	}
+});
+Object.defineProperty(exports, "runApiServers", {
+	enumerable: true,
+	get: function() {
+		return runApiServers;
+	}
+});
+Object.defineProperty(exports, "withApi", {
+	enumerable: true,
+	get: function() {
+		return withApi;
+	}
+});

package/dist/source.d.cts

@@ -1,4 +1,4 @@
-import { f as EvalSource } from "./evals-B6aT3xgH.cjs";
+import { f as EvalSource } from "./evals-B2UuSop0.cjs";
 //#region src/evals/source.d.ts
 declare const repo: (spec: string) => EvalSource;
 declare const files: (contents: Readonly<Record<string, string>>) => EvalSource;

package/dist/source.d.mts

@@ -1,4 +1,4 @@
-import { f as EvalSource } from "./evals-B6aT3xgH.mjs";
+import { f as EvalSource } from "./evals-B2UuSop0.mjs";
 //#region src/evals/source.d.ts
 declare const repo: (spec: string) => EvalSource;
 declare const files: (contents: Readonly<Record<string, string>>) => EvalSource;

package/dist/types-BHokRQpg.d.mts

@@ -0,0 +1,112 @@
+import { t as PublicStartEvalRequest } from "./evals-api-CfAA3cew.mjs";
+import { f as EvalSource, o as EvalHarness } from "./evals-B2UuSop0.mjs";
+import { t as ApiCall } from "./api-mocks-Bz3G00ve.mjs";
+import { t as EvalJudge } from "./eval-judges-JiC8cUCE.mjs";
+import { t as McpCall } from "./calls-DYqBi5FA.mjs";
+import { n as McpServerDefinition } from "./define-HK0eeSNn.mjs";
+import { t as ApiDefinition } from "./define-NZvmQuIv.mjs";
+import { t as CliCall } from "./calls-Drj_dZpu.mjs";
+import { n as CliDefinition } from "./define-BEiYXrC5.mjs";
+//#region src/evals/types.d.ts
+type EvalTaskRequest = PublicStartEvalRequest["tasks"][number];
+/** A profile directory beside the eval file; `dir` resolves against it. */
+interface ProfileRef {
+  readonly dir: string;
+  readonly name: string;
+}
+type HarnessRef = EvalHarness | {
+  readonly base: EvalHarness;
+  readonly profile: ProfileRef;
+};
+interface EvalTaskDefinition {
+  readonly harness: HarnessRef;
+  readonly model: EvalTaskRequest["model"];
+  readonly sandbox?: EvalTaskRequest["sandbox"];
+}
+interface CommandResult {
+  readonly exitCode: number;
+  readonly stderr: string;
+  readonly stdout: string;
+}
+interface ExecOptions {
+  readonly cwd?: string;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly timeoutMs?: number;
+}
+/** Entries are write-once, so the key must name everything the contents
+ * depend on -- a lockfile hash above all. */
+interface CaseCache {
+  readonly key: string;
+  /** Relative to the workspace. */
+  readonly path: string;
+}
+interface PrepareContext {
+  readonly api: {
+    readonly url: (name: string) => Promise<string>;
+  };
+  /** True when the runner restored a cached directory, so a prepare can skip
+   * the work that produced it. */
+  readonly cached: boolean;
+  readonly exec: (file: string, args?: readonly string[], options?: ExecOptions) => Promise<CommandResult>;
+  readonly exists: (path: string) => Promise<boolean>;
+  readonly readText: (path: string) => Promise<string>;
+  readonly workspace: string;
+}
+type PrepareValue = Readonly<Record<string, unknown>>;
+type Prepare = (context: PrepareContext) => Promise<PrepareValue | undefined> | PrepareValue | undefined;
+interface ValidatorContext {
+  /** Empty when the agent said nothing. */
+  readonly answer: () => Promise<string>;
+  readonly api: {
+    readonly url: (name: string) => Promise<string>;
+    readonly calls: (name?: string) => Promise<readonly ApiCall[]>;
+  };
+  readonly cli: {
+    readonly calls: (cli?: string) => Promise<readonly CliCall[]>;
+  };
+  readonly exec: (command: string) => Promise<CommandResult>;
+  readonly exists: (path: string) => Promise<boolean>;
+  readonly mcp: {
+    readonly calls: (server?: string) => Promise<readonly McpCall[]>;
+  };
+  readonly prepared: Readonly<Record<string, unknown>>;
+  readonly readText: (path: string) => Promise<string>;
+  /** Every reply, oldest first, separated by a blank line. */
+  readonly transcript: () => Promise<string>;
+}
+interface ValidatorResult {
+  readonly message?: string;
+  readonly passed: boolean;
+}
+type Validator = (context: ValidatorContext) => boolean | ValidatorResult | Promise<boolean | ValidatorResult>;
+type DeclaredSource = EvalSource | string;
+interface EvalCaseBase {
+  /** Restored before the prepare runs, saved after it succeeds. */
+  readonly cache?: CaseCache;
+  readonly name: string;
+  readonly prepare?: Prepare | null;
+  readonly source?: DeclaredSource;
+  readonly variables?: Readonly<Record<string, string>>;
+}
+type EvalCaseDefinition = EvalCaseBase & ({
+  readonly validate: Validator | EvalJudge | readonly (Validator | EvalJudge)[];
+  readonly verify?: never;
+} | {
+  readonly validate?: never;
+  readonly verify: string;
+});
+interface EvalDefinition {
+  readonly api?: readonly ApiDefinition[];
+  readonly captureSource?: boolean;
+  readonly captureValidation?: boolean;
+  readonly cases: readonly EvalCaseDefinition[];
+  readonly cli?: readonly CliDefinition[];
+  readonly mcp?: readonly McpServerDefinition[];
+  readonly name: string;
+  readonly prompt: string;
+  readonly source?: DeclaredSource;
+  readonly tasks: readonly EvalTaskDefinition[];
+  readonly trials: number;
+}
+//#endregion
+export { EvalTaskDefinition as a, Prepare as c, ProfileRef as d, Validator as f, EvalDefinition as i, PrepareContext as l, ValidatorResult as m, CommandResult as n, ExecOptions as o, ValidatorContext as p, EvalCaseDefinition as r, HarnessRef as s, CaseCache as t, PrepareValue as u };

package/dist/types-UKEi5CCa.d.cts

@@ -0,0 +1,112 @@
+import { t as PublicStartEvalRequest } from "./evals-api-Clbj_nEN.cjs";
+import { f as EvalSource, o as EvalHarness } from "./evals-B2UuSop0.cjs";
+import { t as ApiCall } from "./api-mocks-Bz3G00ve.cjs";
+import { t as EvalJudge } from "./eval-judges-JiC8cUCE.cjs";
+import { t as McpCall } from "./calls-DYqBi5FA.cjs";
+import { n as McpServerDefinition } from "./define-HK0eeSNn.cjs";
+import { t as ApiDefinition } from "./define-NZvmQuIv.cjs";
+import { t as CliCall } from "./calls-Drj_dZpu.cjs";
+import { n as CliDefinition } from "./define-BEiYXrC5.cjs";
+//#region src/evals/types.d.ts
+type EvalTaskRequest = PublicStartEvalRequest["tasks"][number];
+/** A profile directory beside the eval file; `dir` resolves against it. */
+interface ProfileRef {
+  readonly dir: string;
+  readonly name: string;
+}
+type HarnessRef = EvalHarness | {
+  readonly base: EvalHarness;
+  readonly profile: ProfileRef;
+};
+interface EvalTaskDefinition {
+  readonly harness: HarnessRef;
+  readonly model: EvalTaskRequest["model"];
+  readonly sandbox?: EvalTaskRequest["sandbox"];
+}
+interface CommandResult {
+  readonly exitCode: number;
+  readonly stderr: string;
+  readonly stdout: string;
+}
+interface ExecOptions {
+  readonly cwd?: string;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly timeoutMs?: number;
+}
+/** Entries are write-once, so the key must name everything the contents
+ * depend on -- a lockfile hash above all. */
+interface CaseCache {
+  readonly key: string;
+  /** Relative to the workspace. */
+  readonly path: string;
+}
+interface PrepareContext {
+  readonly api: {
+    readonly url: (name: string) => Promise<string>;
+  };
+  /** True when the runner restored a cached directory, so a prepare can skip
+   * the work that produced it. */
+  readonly cached: boolean;
+  readonly exec: (file: string, args?: readonly string[], options?: ExecOptions) => Promise<CommandResult>;
+  readonly exists: (path: string) => Promise<boolean>;
+  readonly readText: (path: string) => Promise<string>;
+  readonly workspace: string;
+}
+type PrepareValue = Readonly<Record<string, unknown>>;
+type Prepare = (context: PrepareContext) => Promise<PrepareValue | undefined> | PrepareValue | undefined;
+interface ValidatorContext {
+  /** Empty when the agent said nothing. */
+  readonly answer: () => Promise<string>;
+  readonly api: {
+    readonly url: (name: string) => Promise<string>;
+    readonly calls: (name?: string) => Promise<readonly ApiCall[]>;
+  };
+  readonly cli: {
+    readonly calls: (cli?: string) => Promise<readonly CliCall[]>;
+  };
+  readonly exec: (command: string) => Promise<CommandResult>;
+  readonly exists: (path: string) => Promise<boolean>;
+  readonly mcp: {
+    readonly calls: (server?: string) => Promise<readonly McpCall[]>;
+  };
+  readonly prepared: Readonly<Record<string, unknown>>;
+  readonly readText: (path: string) => Promise<string>;
+  /** Every reply, oldest first, separated by a blank line. */
+  readonly transcript: () => Promise<string>;
+}
+interface ValidatorResult {
+  readonly message?: string;
+  readonly passed: boolean;
+}
+type Validator = (context: ValidatorContext) => boolean | ValidatorResult | Promise<boolean | ValidatorResult>;
+type DeclaredSource = EvalSource | string;
+interface EvalCaseBase {
+  /** Restored before the prepare runs, saved after it succeeds. */
+  readonly cache?: CaseCache;
+  readonly name: string;
+  readonly prepare?: Prepare | null;
+  readonly source?: DeclaredSource;
+  readonly variables?: Readonly<Record<string, string>>;
+}
+type EvalCaseDefinition = EvalCaseBase & ({
+  readonly validate: Validator | EvalJudge | readonly (Validator | EvalJudge)[];
+  readonly verify?: never;
+} | {
+  readonly validate?: never;
+  readonly verify: string;
+});
+interface EvalDefinition {
+  readonly api?: readonly ApiDefinition[];
+  readonly captureSource?: boolean;
+  readonly captureValidation?: boolean;
+  readonly cases: readonly EvalCaseDefinition[];
+  readonly cli?: readonly CliDefinition[];
+  readonly mcp?: readonly McpServerDefinition[];
+  readonly name: string;
+  readonly prompt: string;
+  readonly source?: DeclaredSource;
+  readonly tasks: readonly EvalTaskDefinition[];
+  readonly trials: number;
+}
+//#endregion
+export { EvalTaskDefinition as a, Prepare as c, ProfileRef as d, Validator as f, EvalDefinition as i, PrepareContext as l, ValidatorResult as m, CommandResult as n, ExecOptions as o, ValidatorContext as p, EvalCaseDefinition as r, HarnessRef as s, CaseCache as t, PrepareValue as u };

package/dist/validator-runtime.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_eval_validations = require("./eval-validations-_MlnQ_uv.cjs");
+const require_eval_validations = require("./eval-validations-CqMUt5ra.cjs");
+const require_api_context = require("./api-context.cjs");
 let effect = require("effect");
 let node_fs_promises = require("node:fs/promises");
 let node_child_process = require("node:child_process");
@@ -117,6 +118,10 @@ const calls = async (path, schema) => {
 	return text.trim() === "" ? [] : text.trim().split("\n").map((line) => decode(line));
 };
 const context = () => ({
+	api: {
+		url: (name) => observe("api.url", [name], () => require_api_context.apiContext.url(name)),
+		calls: (name) => observe("api.calls", name === void 0 ? [] : [name], () => require_api_context.apiContext.calls(name))
+	},
 	answer: () => observe("answer", [], () => readOptional(process.env.ANPORD_ANSWER_FILE)),
 	transcript: () => observe("transcript", [], () => readOptional(process.env.ANPORD_TRANSCRIPT_FILE)),
 	prepared: effect.Schema.decodeUnknownSync(effect.Schema.parseJson(effect.Schema.Record({

package/dist/validator-runtime.d.cts

@@ -1,4 +1,4 @@
-import { f as Validator } from "./types-ISsteq95.cjs";
+import { f as Validator } from "./types-UKEi5CCa.cjs";
 //#region src/evals/validator-runtime.d.ts
 declare const runValidators: (checks: readonly {
   index: number;

package/dist/validator-runtime.d.mts

@@ -1,4 +1,4 @@
-import { f as Validator } from "./types-Codjaq-o.mjs";
+import { f as Validator } from "./types-BHokRQpg.mjs";
 //#region src/evals/validator-runtime.d.ts
 declare const runValidators: (checks: readonly {
   index: number;

package/dist/validator-runtime.mjs

@@ -1,4 +1,5 @@
-import { a as validationExecution, i as validationCapture, n as VALIDATION_FRAME, o as validationSnapshot, r as unavailableValue } from "./eval-validations-BRdoZrTQ.mjs";
+import { a as validationCapture, i as unavailableValue, n as VALIDATION_FRAME, o as validationExecution, s as validationSnapshot } from "./eval-validations-Bmagd2y7.mjs";
+import { apiContext } from "./api-context.mjs";
 import { Schema } from "effect";
 import { access, readFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
@@ -116,6 +117,10 @@ const calls = async (path, schema) => {
 	return text.trim() === "" ? [] : text.trim().split("\n").map((line) => decode(line));
 };
 const context = () => ({
+	api: {
+		url: (name) => observe("api.url", [name], () => apiContext.url(name)),
+		calls: (name) => observe("api.calls", name === void 0 ? [] : [name], () => apiContext.calls(name))
+	},
 	answer: () => observe("answer", [], () => readOptional(process.env.ANPORD_ANSWER_FILE)),
 	transcript: () => observe("transcript", [], () => readOptional(process.env.ANPORD_TRANSCRIPT_FILE)),
 	prepared: Schema.decodeUnknownSync(Schema.parseJson(Schema.Record({

package/dist/validators.d.cts

@@ -1,4 +1,4 @@
-import { n as EvalJudgment, t as EvalJudge } from "./eval-judges-DPPUftbh.cjs";
+import { n as EvalJudgment, t as EvalJudge } from "./eval-judges-JiC8cUCE.cjs";
 //#region src/validators.d.ts
 type JudgeOptions = typeof EvalJudge.Encoded extends (infer Options) ? Options extends {
   readonly kind: "judge";

package/dist/validators.d.mts

@@ -1,4 +1,4 @@
-import { n as EvalJudgment, t as EvalJudge } from "./eval-judges-DPPUftbh.mjs";
+import { n as EvalJudgment, t as EvalJudge } from "./eval-judges-JiC8cUCE.mjs";
 //#region src/validators.d.ts
 type JudgeOptions = typeof EvalJudge.Encoded extends (infer Options) ? Options extends {
   readonly kind: "judge";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anpord",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "TypeScript SDK and CLI for coding agent evals and prompt management.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,26 @@
       }
     },
     "./package.json": "./package.json",
+    "./api": {
+      "import": {
+        "types": "./dist/api.d.mts",
+        "default": "./dist/api.mjs"
+      },
+      "require": {
+        "types": "./dist/api.d.cts",
+        "default": "./dist/api.cjs"
+      }
+    },
+    "./api/runtime": {
+      "import": {
+        "types": "./dist/api-runtime.d.mts",
+        "default": "./dist/api-runtime.mjs"
+      },
+      "require": {
+        "types": "./dist/api-runtime.d.cts",
+        "default": "./dist/api-runtime.cjs"
+      }
+    },
     "./validators": {
       "import": {
         "types": "./dist/validators.d.mts",