@openpond/evals 0.3.0 → 0.4.1

package/dist/types/tasksets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tasksets.d.ts","sourceRoot":"","sources":["../../../../src/tasksets.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tasksets.d.ts","sourceRoot":"","sources":["../../../../src/tasksets.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openpond/evals",
-  "version": "0.3.0",
-  "description": "Portable evaluation, Work evidence, Harness, Taskset, grader, and receipt contracts for OpenPond",
+  "version": "0.4.1",
+  "description": "Portable Tasksets, graders, evaluation runs, receipts, conformance fixtures, and Work evidence for OpenPond Harnesses",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,18 +22,14 @@
       "types": "./dist/types/harness.d.ts",
       "import": "./dist/harness.js"
     },
-    "./harness-improvements": {
-      "types": "./dist/types/harness-improvements.d.ts",
-      "import": "./dist/harness-improvements.js"
-    },
-    "./harness-workspaces": {
-      "types": "./dist/types/harness-workspaces.d.ts",
-      "import": "./dist/harness-workspaces.js"
-    },
     "./tasksets": {
       "types": "./dist/types/tasksets.d.ts",
       "import": "./dist/tasksets.js"
     },
+    "./benchmarks": {
+      "types": "./dist/types/benchmarks.d.ts",
+      "import": "./dist/benchmarks.js"
+    },
     "./graders": {
       "types": "./dist/types/graders.d.ts",
       "import": "./dist/graders.js"
@@ -42,6 +38,14 @@
       "types": "./dist/types/runs.d.ts",
       "import": "./dist/runs.js"
     },
+    "./review": {
+      "types": "./dist/types/review-conformance.d.ts",
+      "import": "./dist/review-conformance.js"
+    },
+    "./model-improvement-qualification": {
+      "types": "./dist/types/model-improvement-qualification.d.ts",
+      "import": "./dist/model-improvement-qualification.js"
+    },
     "./conformance": {
       "types": "./dist/types/conformance.d.ts",
       "import": "./dist/conformance.js"
@@ -79,7 +83,11 @@
   "dependencies": {
     "zod": "^4.1.13"
   },
+  "peerDependencies": {
+    "@openpond/harness": "^0.2.0"
+  },
   "devDependencies": {
+    "@openpond/harness": "workspace:*",
     "@types/node": "24.13.3",
     "tsx": "4.23.1",
     "typescript": "^5.9.3",

package/dist/common.js

@@ -1,67 +0,0 @@
-import { z } from "zod";
-import { sha256Hex } from "./sha256.js";
-export const MAX_PORTABLE_PATH_BYTES = 2_000;
-export const MAX_PORTABLE_ASSET_BYTES = 250_000_000;
-export const ReleaseIdSchema = z.string().trim().min(1).max(240);
-export const ReleaseHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-export const ReleaseTimestampSchema = z.string().datetime({ offset: true });
-export const MetadataSchema = z.record(z.string(), z.unknown()).default({});
-export const ImmutableReleaseRefSchema = z.object({
-    id: ReleaseIdSchema,
-    contentHash: ReleaseHashSchema,
-}).strict();
-export const ImmutableAssetRefSchema = z.object({
-    id: ReleaseIdSchema,
-    path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
-    contentHash: ReleaseHashSchema,
-    sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
-    mediaType: z.string().trim().min(1).max(200),
-    visibility: z.enum(["policy", "verifier", "host_private"]),
-}).strict();
-export const ImmutableArtifactRefSchema = z.object({
-    id: ReleaseIdSchema,
-    contentHash: ReleaseHashSchema,
-    mediaType: z.string().trim().min(1).max(200).nullable().default(null),
-    sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null),
-}).strict();
-export const FailureClassSchema = z.enum([
-    "policy_failure",
-    "grader_failure",
-    "environment_failure",
-    "infrastructure_failure",
-    "timeout",
-    "cancelled",
-]);
-export function canonicalJson(value) {
-    return `${JSON.stringify(sortValue(value), null, 2)}\n`;
-}
-export function sha256(value) {
-    return sha256Hex(value);
-}
-export function contentHash(value) {
-    return sha256(canonicalJson(value));
-}
-export function withContentHash(value) {
-    return { ...value, contentHash: contentHash(value) };
-}
-export function assertContentHash(value, label) {
-    const { contentHash: actual, ...hashable } = value;
-    const expected = contentHash(hashable);
-    if (actual !== expected)
-        throw new Error(`${label} contentHash is ${actual}; expected ${expected}.`);
-}
-function safeRelativePath(value) {
-    const normalized = value.replaceAll("\\", "/");
-    if (!normalized || normalized.startsWith("/") || normalized.includes("\0"))
-        return false;
-    return !normalized.split("/").some((part) => !part || part === "." || part === "..");
-}
-function sortValue(value) {
-    if (Array.isArray(value))
-        return value.map(sortValue);
-    if (!value || typeof value !== "object")
-        return value;
-    return Object.fromEntries(Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, child]) => [key, sortValue(child)]));
-}

package/dist/harness-improvements.js

@@ -1,329 +0,0 @@
-import { z } from "zod";
-import { HarnessImprovementRouteSchema, HarnessOverlaySnapshotRefSchema, } from "./harness-workspaces.js";
-import { contentHash, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, } from "./common.js";
-const BoundedTextSchema = z.string().trim().min(1).max(100_000);
-const MetadataSchema = z.record(z.string(), z.unknown()).default({});
-export const ImprovementSafeBoundaryKindSchema = z.enum([
-    "completed_tool_batch",
-    "before_model_step",
-    "turn_completed",
-    "turn_paused",
-]);
-export const ImprovementSafeBoundarySchema = z
-    .object({
-    kind: ImprovementSafeBoundaryKindSchema,
-    eventSequence: z.number().int().nonnegative(),
-    occurredAt: ReleaseTimestampSchema,
-})
-    .strict();
-export const ImprovementEventRefSchema = z
-    .object({
-    id: ReleaseIdSchema,
-    sequence: z.number().int().nonnegative().nullable(),
-    contentHash: ReleaseHashSchema,
-})
-    .strict();
-export const ImprovementObservationKindSchema = z.enum([
-    "tool_failure",
-    "retry",
-    "recovery",
-    "validation",
-    "user_correction",
-    "reusable_success",
-    "completion_detour",
-]);
-export const ImprovementObservationStateSchema = z.enum([
-    "open",
-    "recovered",
-    "terminal",
-]);
-export const ImprovementToolIdentitySchema = z
-    .object({
-    name: z.string().trim().min(1).max(500),
-    invocationKey: ReleaseHashSchema,
-})
-    .strict();
-export const ImprovementObservationContentSchema = z
-    .object({
-    schemaVersion: z.literal("openpond.improvementObservation.v1"),
-    id: ReleaseIdSchema,
-    runRef: ReleaseIdSchema,
-    turnId: ReleaseIdSchema,
-    harnessRelease: ImmutableReleaseRefSchema,
-    overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-    eventRefs: z.array(ImprovementEventRefSchema).min(1).max(100),
-    kind: ImprovementObservationKindSchema,
-    state: ImprovementObservationStateSchema,
-    tool: ImprovementToolIdentitySchema.nullable(),
-    deterministicClass: z.string().trim().min(1).max(500).nullable(),
-    summary: BoundedTextSchema,
-    createdAt: ReleaseTimestampSchema,
-    metadata: MetadataSchema,
-})
-    .strict()
-    .superRefine((observation, context) => {
-    if (new Set(observation.eventRefs.map((reference) => reference.id)).size !==
-        observation.eventRefs.length) {
-        context.addIssue({
-            code: "custom",
-            message: "observation event refs must be unique",
-            path: ["eventRefs"],
-        });
-    }
-    if (["tool_failure", "retry", "recovery", "completion_detour"].includes(observation.kind) &&
-        observation.tool === null) {
-        context.addIssue({
-            code: "custom",
-            message: `${observation.kind} observations require a tool identity`,
-            path: ["tool"],
-        });
-    }
-});
-export const ImprovementObservationSchema = ImprovementObservationContentSchema.extend({
-    contentHash: ReleaseHashSchema,
-}).strict();
-export const RefinementTriggerPolicySchema = z
-    .object({
-    schemaVersion: z.literal("openpond.refinementTriggerPolicy.v1"),
-    maxEstimatedCostUsd: z.number().finite().nonnegative(),
-    cooldownMs: z.number().int().nonnegative(),
-    maxPendingPlans: z.number().int().min(1).max(100),
-    maxEvidenceEvents: z.number().int().min(1).max(1_000),
-    maxProposalEdits: z.number().int().min(1).max(1_000),
-    maxProposalBytes: z.number().int().min(1).max(10_000_000),
-})
-    .strict();
-export const RefinementTriggerDecisionKindSchema = z.enum([
-    "no_action",
-    "route_deterministically",
-    "queue_refiner",
-]);
-export const RefinementTriggerDecisionContentSchema = z
-    .object({
-    schemaVersion: z.literal("openpond.refinementTriggerDecision.v1"),
-    id: ReleaseIdSchema,
-    runRef: ReleaseIdSchema,
-    turnId: ReleaseIdSchema,
-    harnessRelease: ImmutableReleaseRefSchema,
-    overlay: HarnessOverlaySnapshotRefSchema.nullable(),
-    observations: z.array(ImmutableReleaseRefSchema).max(100),
-    decision: RefinementTriggerDecisionKindSchema,
-    deterministicRoute: HarnessImprovementRouteSchema.nullable(),
-    suggestedRoutes: z.array(HarnessImprovementRouteSchema).max(8),
-    reason: BoundedTextSchema,
-    deduplicationKey: ReleaseHashSchema,
-    policy: RefinementTriggerPolicySchema,
-    estimatedMaxCostUsd: z.number().finite().nonnegative(),
-    pendingPlanCount: z.number().int().nonnegative(),
-    boundary: ImprovementSafeBoundarySchema,
-    cooldownUntil: ReleaseTimestampSchema.nullable(),
-    createdAt: ReleaseTimestampSchema,
-    metadata: MetadataSchema,
-})
-    .strict()
-    .superRefine((trigger, context) => {
-    if (trigger.estimatedMaxCostUsd > trigger.policy.maxEstimatedCostUsd) {
-        context.addIssue({
-            code: "custom",
-            message: "estimated Refiner cost exceeds the trigger policy budget",
-            path: ["estimatedMaxCostUsd"],
-        });
-    }
-    if (trigger.pendingPlanCount > trigger.policy.maxPendingPlans) {
-        context.addIssue({
-            code: "custom",
-            message: "pending plan count exceeds the trigger policy limit",
-            path: ["pendingPlanCount"],
-        });
-    }
-    if (trigger.observations.length > trigger.policy.maxEvidenceEvents) {
-        context.addIssue({
-            code: "custom",
-            message: "trigger observations exceed the evidence budget",
-            path: ["observations"],
-        });
-    }
-    if (trigger.decision === "route_deterministically" &&
-        trigger.deterministicRoute === null) {
-        context.addIssue({
-            code: "custom",
-            message: "deterministic decisions require a route",
-            path: ["deterministicRoute"],
-        });
-    }
-    if (trigger.decision !== "route_deterministically" &&
-        trigger.deterministicRoute !== null) {
-        context.addIssue({
-            code: "custom",
-            message: "only deterministic decisions may declare a deterministic route",
-            path: ["deterministicRoute"],
-        });
-    }
-    if (trigger.decision === "no_action" && trigger.suggestedRoutes.length > 0) {
-        context.addIssue({
-            code: "custom",
-            message: "no-action decisions cannot suggest routes",
-            path: ["suggestedRoutes"],
-        });
-    }
-    if (trigger.decision !== "no_action" && trigger.observations.length === 0) {
-        context.addIssue({
-            code: "custom",
-            message: "actionable trigger decisions require observations",
-            path: ["observations"],
-        });
-    }
-});
-export const RefinementTriggerDecisionSchema = RefinementTriggerDecisionContentSchema.extend({
-    contentHash: ReleaseHashSchema,
-}).strict();
-export const ImprovementRouteAuthoritySchema = z.enum([
-    "runtime_service",
-    "refiner_model",
-    "human_review",
-    "evaluation_system",
-    "training_system",
-]);
-export const ImprovementRouteDecisionContentSchema = z
-    .object({
-    schemaVersion: z.literal("openpond.improvementRouteDecision.v1"),
-    id: ReleaseIdSchema,
-    trigger: ImmutableReleaseRefSchema,
-    route: HarnessImprovementRouteSchema,
-    authority: ImprovementRouteAuthoritySchema,
-    automatic: z.boolean(),
-    reason: BoundedTextSchema,
-    createdAt: ReleaseTimestampSchema,
-    metadata: MetadataSchema,
-})
-    .strict()
-    .superRefine((decision, context) => {
-    if (decision.automatic &&
-        ["human_review", "evaluation_system", "training_system"].includes(decision.authority)) {
-        context.addIssue({
-            code: "custom",
-            message: `${decision.authority} routes cannot be marked automatic`,
-            path: ["automatic"],
-        });
-    }
-    if (decision.route === "training" && decision.authority !== "training_system") {
-        context.addIssue({
-            code: "custom",
-            message: "training routes require training-system authority",
-            path: ["authority"],
-        });
-    }
-});
-export const ImprovementRouteDecisionSchema = ImprovementRouteDecisionContentSchema.extend({
-    contentHash: ReleaseHashSchema,
-}).strict();
-export const HarnessRefinerOutcomeContentSchema = z
-    .object({
-    schemaVersion: z.literal("openpond.harnessRefinerOutcome.v1"),
-    id: ReleaseIdSchema,
-    trigger: ImmutableReleaseRefSchema,
-    decision: z.enum(["no_action", "proposed"]),
-    proposal: ImmutableReleaseRefSchema.nullable(),
-    reason: BoundedTextSchema,
-    evidenceRefs: z.array(ImmutableReleaseRefSchema).max(100),
-    estimatedCostUsd: z.number().finite().nonnegative(),
-    createdAt: ReleaseTimestampSchema,
-    metadata: MetadataSchema,
-})
-    .strict()
-    .superRefine((outcome, context) => {
-    if ((outcome.decision === "proposed") !== (outcome.proposal !== null)) {
-        context.addIssue({
-            code: "custom",
-            message: "proposed Refiner outcomes require a proposal; no-action outcomes cannot include one",
-            path: ["proposal"],
-        });
-    }
-});
-export const HarnessRefinerOutcomeSchema = HarnessRefinerOutcomeContentSchema.extend({
-    contentHash: ReleaseHashSchema,
-}).strict();
-export const ImprovementApplyDecisionSchema = z.enum([
-    "applied",
-    "retained",
-    "declined",
-    "conflict",
-    "rolled_back",
-]);
-export const ImprovementApplyReceiptContentSchema = z
-    .object({
-    schemaVersion: z.literal("openpond.improvementApplyReceipt.v1"),
-    id: ReleaseIdSchema,
-    proposal: ImmutableReleaseRefSchema,
-    beforeOverlay: HarnessOverlaySnapshotRefSchema,
-    afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
-    decision: ImprovementApplyDecisionSchema,
-    boundary: ImprovementSafeBoundarySchema,
-    validationRefs: z.array(ImmutableReleaseRefSchema).max(100),
-    outcomeEvidenceRefs: z.array(ImprovementEventRefSchema).max(1_000),
-    rollbackOf: ImmutableReleaseRefSchema.nullable(),
-    createdAt: ReleaseTimestampSchema,
-    metadata: MetadataSchema,
-})
-    .strict()
-    .superRefine((receipt, context) => {
-    if ((receipt.decision === "applied") !== (receipt.afterOverlay !== null)) {
-        context.addIssue({
-            code: "custom",
-            message: "applied receipts require an after-overlay; other decisions cannot include one",
-            path: ["afterOverlay"],
-        });
-    }
-    if ((receipt.decision === "rolled_back") !== (receipt.rollbackOf !== null)) {
-        context.addIssue({
-            code: "custom",
-            message: "only rollback receipts require rollbackOf",
-            path: ["rollbackOf"],
-        });
-    }
-});
-export const ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend({
-    contentHash: ReleaseHashSchema,
-}).strict();
-function createHashedContract(input) {
-    const parsed = input.contentSchema.parse(input.content);
-    return input.resultSchema.parse({
-        ...parsed,
-        contentHash: contentHash(parsed),
-    });
-}
-export function createImprovementObservation(content) {
-    return createHashedContract({
-        content,
-        contentSchema: ImprovementObservationContentSchema,
-        resultSchema: ImprovementObservationSchema,
-    });
-}
-export function createRefinementTriggerDecision(content) {
-    return createHashedContract({
-        content,
-        contentSchema: RefinementTriggerDecisionContentSchema,
-        resultSchema: RefinementTriggerDecisionSchema,
-    });
-}
-export function createImprovementRouteDecision(content) {
-    return createHashedContract({
-        content,
-        contentSchema: ImprovementRouteDecisionContentSchema,
-        resultSchema: ImprovementRouteDecisionSchema,
-    });
-}
-export function createHarnessRefinerOutcome(content) {
-    return createHashedContract({
-        content,
-        contentSchema: HarnessRefinerOutcomeContentSchema,
-        resultSchema: HarnessRefinerOutcomeSchema,
-    });
-}
-export function createImprovementApplyReceipt(content) {
-    return createHashedContract({
-        content,
-        contentSchema: ImprovementApplyReceiptContentSchema,
-        resultSchema: ImprovementApplyReceiptSchema,
-    });
-}