anpord 0.1.11 → 0.1.13

package/dist/eval-judges-DPPUftbh.d.mts

@@ -0,0 +1,48 @@
+import { Schema } from "effect";
+//#region ../schema/src/domain/eval-judges.d.ts
+declare const EvalJudge: Schema.Union<[Schema.Struct<{
+  provider: Schema.Literal<["openai"]>;
+  harness: Schema.optional<typeof Schema.Never>;
+  kind: Schema.Literal<["judge"]>;
+  name: Schema.filter<Schema.filter<typeof Schema.String>>;
+  model: Schema.filter<Schema.filter<typeof Schema.String>>;
+  rubric: Schema.filter<Schema.filter<typeof Schema.String>>;
+  expected: Schema.optional<Schema.filter<typeof Schema.String>>;
+  choices: Schema.filter<Schema.Record$<Schema.filter<typeof Schema.String>, Schema.filter<typeof Schema.Number>>>;
+  threshold: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
+    default: () => number;
+  }>;
+  timeoutMs: Schema.optionalWith<Schema.filter<typeof Schema.Int>, {
+    default: () => number;
+  }>;
+}>, Schema.Struct<{
+  provider: Schema.optional<typeof Schema.Never>;
+  harness: Schema.SchemaClass<"codex" | "opencode" | "pi" | "fx" | "claude" | "gemini" | "qwen" | "cursor", "codex" | "opencode" | "pi" | "fx" | "claude" | "gemini" | "qwen" | "cursor", never>;
+  kind: Schema.Literal<["judge"]>;
+  name: Schema.filter<Schema.filter<typeof Schema.String>>;
+  model: Schema.filter<Schema.filter<typeof Schema.String>>;
+  rubric: Schema.filter<Schema.filter<typeof Schema.String>>;
+  expected: Schema.optional<Schema.filter<typeof Schema.String>>;
+  choices: Schema.filter<Schema.Record$<Schema.filter<typeof Schema.String>, Schema.filter<typeof Schema.Number>>>;
+  threshold: Schema.optionalWith<Schema.filter<typeof Schema.Number>, {
+    default: () => number;
+  }>;
+  timeoutMs: Schema.optionalWith<Schema.filter<typeof Schema.Int>, {
+    default: () => number;
+  }>;
+}>]>;
+type EvalJudge = typeof EvalJudge.Type;
+declare const EvalJudgment: Schema.Struct<{
+  name: typeof Schema.String;
+  model: typeof Schema.String;
+  evaluator: typeof Schema.String;
+  score: Schema.NullOr<Schema.filter<typeof Schema.Number>>;
+  choice: Schema.NullOr<typeof Schema.String>;
+  reason: typeof Schema.String;
+  threshold: Schema.filter<typeof Schema.Number>;
+  durationMs: Schema.refine<number, typeof Schema.NonNegative>;
+  error: Schema.NullOr<typeof Schema.String>;
+}>;
+type EvalJudgment = typeof EvalJudgment.Type;
+//#endregion
+export { EvalJudgment as n, EvalJudge as t };

package/dist/eval-validations-BRdoZrTQ.mjs

@@ -0,0 +1,113 @@
+import { n as EvalJudgment } from "./eval-judges-CwTvTq7N.mjs";
+import { Schema } from "effect";
+//#region ../schema/src/domain/eval-validations.ts
+const VALIDATION_TEXT_LIMIT = 16e3;
+const VALIDATION_BUDGET = 64e3;
+const VALIDATION_FRAME = "ANPORD_VALIDATION=";
+const ValidationValue = Schema.Struct({
+	text: Schema.String.pipe(Schema.maxLength(VALIDATION_TEXT_LIMIT)),
+	format: Schema.Literal("text", "json"),
+	state: Schema.Literal("captured", "disabled", "unavailable"),
+	truncated: Schema.Boolean
+}).annotations({ identifier: "ValidationValue" });
+const ValidationCall = Schema.Struct({
+	index: Schema.NonNegativeInt,
+	method: Schema.Literal("answer", "transcript", "readText", "exists", "exec", "cli.calls", "mcp.calls"),
+	startedAt: Schema.Number,
+	durationMs: Schema.NullOr(Schema.NonNegativeInt),
+	input: ValidationValue,
+	output: ValidationValue,
+	error: Schema.NullOr(ValidationValue)
+}).annotations({ identifier: "ValidationCall" });
+const EvalValidation = Schema.Struct({
+	id: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(200)),
+	index: Schema.NonNegativeInt,
+	name: Schema.String.pipe(Schema.maxLength(200)),
+	kind: Schema.Literal("code", "judge", "command"),
+	status: Schema.Literal("queued", "running", "passed", "failed", "error", "skipped"),
+	startedAt: Schema.NullOr(Schema.Number),
+	durationMs: Schema.NullOr(Schema.NonNegativeInt),
+	message: Schema.String.pipe(Schema.maxLength(2e3)),
+	exitCode: Schema.NullOr(Schema.Int),
+	truncated: Schema.Boolean,
+	judgment: Schema.optional(EvalJudgment),
+	input: ValidationValue,
+	output: ValidationValue,
+	error: Schema.NullOr(ValidationValue),
+	metadata: Schema.optional(ValidationValue),
+	calls: Schema.Array(ValidationCall).pipe(Schema.maxItems(64)),
+	logs: Schema.Array(Schema.Struct({
+		index: Schema.NonNegativeInt,
+		at: Schema.Number,
+		level: Schema.Literal("stdout", "stderr"),
+		value: ValidationValue
+	})).pipe(Schema.maxItems(64))
+}).annotations({ identifier: "EvalValidation" });
+const EvalValidations = Schema.Array(EvalValidation).pipe(Schema.maxItems(40)).annotations({ identifier: "EvalValidations" });
+const validationSnapshot = (value) => ({
+	...value,
+	truncated: value.truncated || [
+		value.input,
+		value.output,
+		value.error,
+		value.metadata,
+		...value.calls.flatMap((call) => [
+			call.input,
+			call.output,
+			call.error
+		]),
+		...value.logs.map((log) => log.value)
+	].some((field) => field?.truncated)
+});
+const unavailableValue = {
+	text: "",
+	format: "text",
+	state: "unavailable",
+	truncated: false
+};
+const validationCapture = (enabled = true) => {
+	let remaining = VALIDATION_BUDGET;
+	return (value, format = "json") => {
+		if (!enabled) return {
+			...unavailableValue,
+			state: "disabled",
+			format
+		};
+		try {
+			const raw = format === "text" ? String(value) : JSON.stringify(value);
+			if (raw === void 0) return {
+				...unavailableValue,
+				format
+			};
+			const text = raw.slice(0, Math.min(remaining, VALIDATION_TEXT_LIMIT));
+			remaining -= text.length;
+			return {
+				text,
+				format,
+				state: "captured",
+				truncated: text.length < raw.length
+			};
+		} catch {
+			return {
+				...unavailableValue,
+				format
+			};
+		}
+	};
+};
+const validationExecution = (identity, startedAt) => ({
+	...identity,
+	startedAt,
+	status: startedAt === null ? "skipped" : "running",
+	durationMs: null,
+	exitCode: null,
+	message: "",
+	truncated: false,
+	input: unavailableValue,
+	output: unavailableValue,
+	error: null,
+	calls: [],
+	logs: []
+});
+//#endregion
+export { validationExecution as a, validationCapture as i, VALIDATION_FRAME as n, validationSnapshot as o, unavailableValue as r, EvalValidations as t };

package/dist/eval-validations-_MlnQ_uv.cjs

@@ -0,0 +1,148 @@
+const require_eval_judges = require("./eval-judges-BkmiVLLq.cjs");
+let effect = require("effect");
+//#region ../schema/src/domain/eval-validations.ts
+const VALIDATION_TEXT_LIMIT = 16e3;
+const VALIDATION_BUDGET = 64e3;
+const VALIDATION_FRAME = "ANPORD_VALIDATION=";
+const ValidationValue = effect.Schema.Struct({
+	text: effect.Schema.String.pipe(effect.Schema.maxLength(VALIDATION_TEXT_LIMIT)),
+	format: effect.Schema.Literal("text", "json"),
+	state: effect.Schema.Literal("captured", "disabled", "unavailable"),
+	truncated: effect.Schema.Boolean
+}).annotations({ identifier: "ValidationValue" });
+const ValidationCall = effect.Schema.Struct({
+	index: effect.Schema.NonNegativeInt,
+	method: effect.Schema.Literal("answer", "transcript", "readText", "exists", "exec", "cli.calls", "mcp.calls"),
+	startedAt: effect.Schema.Number,
+	durationMs: effect.Schema.NullOr(effect.Schema.NonNegativeInt),
+	input: ValidationValue,
+	output: ValidationValue,
+	error: effect.Schema.NullOr(ValidationValue)
+}).annotations({ identifier: "ValidationCall" });
+const EvalValidation = effect.Schema.Struct({
+	id: effect.Schema.String.pipe(effect.Schema.minLength(1), effect.Schema.maxLength(200)),
+	index: effect.Schema.NonNegativeInt,
+	name: effect.Schema.String.pipe(effect.Schema.maxLength(200)),
+	kind: effect.Schema.Literal("code", "judge", "command"),
+	status: effect.Schema.Literal("queued", "running", "passed", "failed", "error", "skipped"),
+	startedAt: effect.Schema.NullOr(effect.Schema.Number),
+	durationMs: effect.Schema.NullOr(effect.Schema.NonNegativeInt),
+	message: effect.Schema.String.pipe(effect.Schema.maxLength(2e3)),
+	exitCode: effect.Schema.NullOr(effect.Schema.Int),
+	truncated: effect.Schema.Boolean,
+	judgment: effect.Schema.optional(require_eval_judges.EvalJudgment),
+	input: ValidationValue,
+	output: ValidationValue,
+	error: effect.Schema.NullOr(ValidationValue),
+	metadata: effect.Schema.optional(ValidationValue),
+	calls: effect.Schema.Array(ValidationCall).pipe(effect.Schema.maxItems(64)),
+	logs: effect.Schema.Array(effect.Schema.Struct({
+		index: effect.Schema.NonNegativeInt,
+		at: effect.Schema.Number,
+		level: effect.Schema.Literal("stdout", "stderr"),
+		value: ValidationValue
+	})).pipe(effect.Schema.maxItems(64))
+}).annotations({ identifier: "EvalValidation" });
+const EvalValidations = effect.Schema.Array(EvalValidation).pipe(effect.Schema.maxItems(40)).annotations({ identifier: "EvalValidations" });
+const validationSnapshot = (value) => ({
+	...value,
+	truncated: value.truncated || [
+		value.input,
+		value.output,
+		value.error,
+		value.metadata,
+		...value.calls.flatMap((call) => [
+			call.input,
+			call.output,
+			call.error
+		]),
+		...value.logs.map((log) => log.value)
+	].some((field) => field?.truncated)
+});
+const unavailableValue = {
+	text: "",
+	format: "text",
+	state: "unavailable",
+	truncated: false
+};
+const validationCapture = (enabled = true) => {
+	let remaining = VALIDATION_BUDGET;
+	return (value, format = "json") => {
+		if (!enabled) return {
+			...unavailableValue,
+			state: "disabled",
+			format
+		};
+		try {
+			const raw = format === "text" ? String(value) : JSON.stringify(value);
+			if (raw === void 0) return {
+				...unavailableValue,
+				format
+			};
+			const text = raw.slice(0, Math.min(remaining, VALIDATION_TEXT_LIMIT));
+			remaining -= text.length;
+			return {
+				text,
+				format,
+				state: "captured",
+				truncated: text.length < raw.length
+			};
+		} catch {
+			return {
+				...unavailableValue,
+				format
+			};
+		}
+	};
+};
+const validationExecution = (identity, startedAt) => ({
+	...identity,
+	startedAt,
+	status: startedAt === null ? "skipped" : "running",
+	durationMs: null,
+	exitCode: null,
+	message: "",
+	truncated: false,
+	input: unavailableValue,
+	output: unavailableValue,
+	error: null,
+	calls: [],
+	logs: []
+});
+//#endregion
+Object.defineProperty(exports, "EvalValidations", {
+	enumerable: true,
+	get: function() {
+		return EvalValidations;
+	}
+});
+Object.defineProperty(exports, "VALIDATION_FRAME", {
+	enumerable: true,
+	get: function() {
+		return VALIDATION_FRAME;
+	}
+});
+Object.defineProperty(exports, "unavailableValue", {
+	enumerable: true,
+	get: function() {
+		return unavailableValue;
+	}
+});
+Object.defineProperty(exports, "validationCapture", {
+	enumerable: true,
+	get: function() {
+		return validationCapture;
+	}
+});
+Object.defineProperty(exports, "validationExecution", {
+	enumerable: true,
+	get: function() {
+		return validationExecution;
+	}
+});
+Object.defineProperty(exports, "validationSnapshot", {
+	enumerable: true,
+	get: function() {
+		return validationSnapshot;
+	}
+});

package/dist/eval.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_compiler = require("./compiler-Ap8DM-JU.cjs");
+const require_compiler = require("./compiler-uwb1pkdK.cjs");
 exports.compileEval = require_compiler.compileEval;
 exports.compileEvalEffect = require_compiler.compileEvalEffect;

package/dist/eval.d.cts

@@ -1,4 +1,4 @@
-import { h as PublicStartEvalRequest, t as CaseCache } from "./types-H9L450Iu.cjs";
+import { h as PublicStartEvalRequest, t as CaseCache } from "./types-ISsteq95.cjs";
 import { Effect } from "effect";
 //#region src/evals/profile-errors.d.ts
 declare const ProfileDirectoryUnreadable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -82,9 +82,63 @@ declare class ProfileStepNotSupported extends ProfileStepNotSupported_base<{
 //#region src/evals/compiler.d.ts
 declare const compileEvalEffect: (path: string) => Effect.Effect<{
   cases: {
-    validator: {
-      name: string;
-      source: string;
+    validator: ({
+      readonly name: string;
+      readonly source: string;
+      readonly capture?: boolean | undefined;
+      readonly manifest?: readonly {
+        readonly name: string;
+        readonly index: number;
+      }[] | undefined;
+    } & {
+      readonly sourceFiles?: readonly {
+        readonly path: string;
+        readonly content: string;
+      }[] | undefined;
+    }) | {
+      readonly name: string;
+      readonly kind: "judged";
+      readonly capture?: boolean | undefined;
+      readonly sourceFiles?: readonly {
+        readonly path: string;
+        readonly content: string;
+      }[] | undefined;
+      readonly checks: readonly {
+        readonly name: string;
+        readonly source: string;
+        readonly capture?: boolean | undefined;
+        readonly manifest?: readonly {
+          readonly name: string;
+          readonly index: number;
+        }[] | undefined;
+      }[];
+      readonly judges: readonly ({
+        readonly name: string;
+        readonly kind: "judge";
+        readonly harness?: undefined;
+        readonly model: string;
+        readonly provider: "openai";
+        readonly rubric: string;
+        readonly expected?: string | undefined;
+        readonly choices: {
+          readonly [x: string]: number;
+        };
+        readonly threshold: number;
+        readonly timeoutMs: number;
+      } | {
+        readonly name: string;
+        readonly kind: "judge";
+        readonly harness: "cursor" | "codex" | "opencode" | "pi" | "fx" | "claude" | "gemini" | "qwen";
+        readonly model: string;
+        readonly provider?: undefined;
+        readonly rubric: string;
+        readonly expected?: string | undefined;
+        readonly choices: {
+          readonly [x: string]: number;
+        };
+        readonly threshold: number;
+        readonly timeoutMs: number;
+      })[];
     } | null;
     variables: Readonly<Record<string, string>>;
     verify: string | null;
@@ -112,10 +166,10 @@ declare const compileEvalEffect: (path: string) => Effect.Effect<{
       readonly run?: string | undefined;
       readonly systemPrompt?: string | undefined;
     } | undefined;
-    readonly provider: "daytona" | "e2b" | "upstash" | "modal" | "cloudflare" | "vercel";
+    readonly sandbox?: "daytona" | "e2b" | "upstash" | "modal" | "cloudflare" | "vercel" | undefined;
   }[];
   trials: number;
-}, Error | ProfileTooManyFiles | ProfileDirectoryUnreadable | ProfileTooLarge | ProfileFileTooLarge | ProfilePathInvalid | ProfileManifestInvalid | ProfileManifestOutside | CommandProfileNeedsRun | ProfileStepNotSupported, never>;
+}, Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | ProfileTooManyFiles | ProfileDirectoryUnreadable | ProfileTooLarge | ProfileFileTooLarge | ProfilePathInvalid | ProfileManifestInvalid | ProfileManifestOutside | CommandProfileNeedsRun | ProfileStepNotSupported, never>;
 declare const compileEval: (path: string) => Promise<PublicStartEvalRequest>;
 //#endregion
 export { compileEval, compileEvalEffect };

package/dist/eval.d.mts

@@ -1,4 +1,4 @@
-import { h as PublicStartEvalRequest, t as CaseCache } from "./types-oaMF6-E1.mjs";
+import { h as PublicStartEvalRequest, t as CaseCache } from "./types-Codjaq-o.mjs";
 import { Effect } from "effect";
 //#region src/evals/profile-errors.d.ts
 declare const ProfileDirectoryUnreadable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -82,9 +82,63 @@ declare class ProfileStepNotSupported extends ProfileStepNotSupported_base<{
 //#region src/evals/compiler.d.ts
 declare const compileEvalEffect: (path: string) => Effect.Effect<{
   cases: {
-    validator: {
-      name: string;
-      source: string;
+    validator: ({
+      readonly name: string;
+      readonly source: string;
+      readonly capture?: boolean | undefined;
+      readonly manifest?: readonly {
+        readonly name: string;
+        readonly index: number;
+      }[] | undefined;
+    } & {
+      readonly sourceFiles?: readonly {
+        readonly path: string;
+        readonly content: string;
+      }[] | undefined;
+    }) | {
+      readonly name: string;
+      readonly kind: "judged";
+      readonly capture?: boolean | undefined;
+      readonly sourceFiles?: readonly {
+        readonly path: string;
+        readonly content: string;
+      }[] | undefined;
+      readonly checks: readonly {
+        readonly name: string;
+        readonly source: string;
+        readonly capture?: boolean | undefined;
+        readonly manifest?: readonly {
+          readonly name: string;
+          readonly index: number;
+        }[] | undefined;
+      }[];
+      readonly judges: readonly ({
+        readonly name: string;
+        readonly kind: "judge";
+        readonly harness?: undefined;
+        readonly model: string;
+        readonly provider: "openai";
+        readonly rubric: string;
+        readonly expected?: string | undefined;
+        readonly choices: {
+          readonly [x: string]: number;
+        };
+        readonly threshold: number;
+        readonly timeoutMs: number;
+      } | {
+        readonly name: string;
+        readonly kind: "judge";
+        readonly harness: "cursor" | "codex" | "opencode" | "pi" | "fx" | "claude" | "gemini" | "qwen";
+        readonly model: string;
+        readonly provider?: undefined;
+        readonly rubric: string;
+        readonly expected?: string | undefined;
+        readonly choices: {
+          readonly [x: string]: number;
+        };
+        readonly threshold: number;
+        readonly timeoutMs: number;
+      })[];
     } | null;
     variables: Readonly<Record<string, string>>;
     verify: string | null;
@@ -112,10 +166,10 @@ declare const compileEvalEffect: (path: string) => Effect.Effect<{
       readonly run?: string | undefined;
       readonly systemPrompt?: string | undefined;
     } | undefined;
-    readonly provider: "daytona" | "e2b" | "upstash" | "modal" | "cloudflare" | "vercel";
+    readonly sandbox?: "daytona" | "e2b" | "upstash" | "modal" | "cloudflare" | "vercel" | undefined;
   }[];
   trials: number;
-}, Error | ProfileTooManyFiles | ProfileDirectoryUnreadable | ProfileTooLarge | ProfileFileTooLarge | ProfilePathInvalid | ProfileManifestInvalid | ProfileManifestOutside | CommandProfileNeedsRun | ProfileStepNotSupported, never>;
+}, Error | import("effect/ConfigError").ConfigError | import("effect/ParseResult").ParseError | ProfileTooManyFiles | ProfileDirectoryUnreadable | ProfileTooLarge | ProfileFileTooLarge | ProfilePathInvalid | ProfileManifestInvalid | ProfileManifestOutside | CommandProfileNeedsRun | ProfileStepNotSupported, never>;
 declare const compileEval: (path: string) => Promise<PublicStartEvalRequest>;
 //#endregion
 export { compileEval, compileEvalEffect };

package/dist/eval.mjs

@@ -1,2 +1,2 @@
-import { n as compileEvalEffect, t as compileEval } from "./compiler-DXlpU_In.mjs";
+import { n as compileEvalEffect, t as compileEval } from "./compiler-D96wI7UP.mjs";
 export { compileEval, compileEvalEffect };