openpond-sdk 0.5.3 → 0.5.4

package/dist/{chunk-OJERFIEJ.js → chunk-36A46YZX.js}

@@ -14,15 +14,81 @@ import {
 } from "./chunk-ZNFOVV7B.js";
 
 // src/training.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
-// src/training-grading-plan.ts
+// src/training-evaluation-results.ts
 import { z } from "zod";
+var IdSchema = z.string().trim().min(1).max(500);
+var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var TrainingEvaluationTaskResultSchema = z.object({
+  taskId: IdSchema,
+  taskSha256: HashSchema,
+  resultSha256: HashSchema,
+  input: z.object({
+    instruction: z.string().max(1e6),
+    context: z.record(z.string(), z.unknown())
+  }).strict(),
+  output: z.string().max(1e6),
+  outputSha256: HashSchema,
+  score: z.number().finite().min(0).max(1),
+  evidence: z.object({
+    kind: z.enum(["worker_command", "hosted_trace", "local_trace"]),
+    id: IdSchema
+  }).strict()
+}).strict();
+var TrainingEvaluationTaskPageSchema = z.object({
+  schemaVersion: z.literal("openpond.trainingEvaluationTaskPage.v1"),
+  jobId: IdSchema,
+  teamId: IdSchema,
+  evaluation: ModelProjectImmutableRefSchema,
+  kind: z.enum(["baseline", "candidate"]),
+  policyVersion: z.number().int().nonnegative(),
+  taskset: ModelProjectVersionedRefSchema,
+  panelSha256: HashSchema,
+  offset: z.number().int().nonnegative(),
+  total: z.number().int().min(1).max(1e4),
+  tasks: z.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
+  nextCursor: z.string().regex(/^[1-9]\d*$/).nullable(),
+  contentHash: HashSchema
+}).strict().superRefine((page, context) => {
+  const end = page.offset + page.tasks.length;
+  const expectedCursor = end < page.total ? String(end) : null;
+  if (end > page.total || page.nextCursor !== expectedCursor) {
+    context.addIssue({ code: "custom", path: ["nextCursor"], message: "Evaluation pagination must cover consecutive task positions." });
+  }
+  if (new Set(page.tasks.map((task) => task.taskId)).size !== page.tasks.length) {
+    context.addIssue({ code: "custom", path: ["tasks"], message: "Evaluation task identities must be unique." });
+  }
+});
+async function trainingEvaluationTaskPageHash(value) {
+  const { contentHash: _contentHash, ...content } = value;
+  return canonicalSha256(content);
+}
+async function parseAndVerifyTrainingEvaluationTaskPage(value, expected) {
+  assertCanonicalPayloadSize(value, TRAINING_API_RESPONSE_MAX_BYTES, "Training evaluation task page");
+  const page = TrainingEvaluationTaskPageSchema.parse(value);
+  const reference = ModelProjectImmutableRefSchema.parse(expected.evaluation);
+  if (page.jobId !== IdSchema.parse(expected.jobId) || page.evaluation.id !== reference.id || page.evaluation.contentHash !== reference.contentHash || page.offset !== (expected.offset ?? 0) || expected.teamId !== void 0 && page.teamId !== IdSchema.parse(expected.teamId)) {
+    throw new OpenPondProtocolError("evaluation_page_identity_mismatch", "Evaluation results differ from the requested Job, evaluation, or page.");
+  }
+  if (await trainingEvaluationTaskPageHash(page) !== page.contentHash) {
+    throw new OpenPondProtocolError("evaluation_page_hash_mismatch", "Evaluation task page content hash did not match.");
+  }
+  for (const task of page.tasks) {
+    if (await canonicalSha256(task.output) !== task.outputSha256) {
+      throw new OpenPondProtocolError("evaluation_output_hash_mismatch", "A retained evaluation output hash did not match.");
+    }
+  }
+  return page;
+}
+
+// src/training-grading-plan.ts
+import { z as z2 } from "zod";
 import { compileBoundGraders, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
-var GradersSchema = z.array(z.object({ id: z.string().trim().min(1) }).catchall(z.unknown())).min(1).max(1e3);
-var RewardExecutionSchema = z.object({
+var GradersSchema = z2.array(z2.object({ id: z2.string().trim().min(1) }).catchall(z2.unknown())).min(1).max(1e3);
+var RewardExecutionSchema = z2.object({
   binding: RewardBindingSchema,
-  rewards: z.array(RewardReleaseSchema).min(1).max(100)
+  rewards: z2.array(RewardReleaseSchema).min(1).max(100)
 }).strict();
 async function deterministicTrainingRewardSource(input) {
   const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
@@ -39,23 +105,23 @@ async function deterministicTrainingRewardSource(input) {
 }
 
 // src/training-evaluation-source.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var TRAINING_EVALUATION_SOURCE_PATH = "evaluation-source.json";
-var TaskIdentitySchema = z2.object({
-  id: z2.string().trim().min(1),
-  clusterKey: z2.string().trim().min(1),
-  split: z2.enum(["train", "validation", "frozen_eval"])
+var TaskIdentitySchema = z3.object({
+  id: z3.string().trim().min(1),
+  clusterKey: z3.string().trim().min(1),
+  split: z3.enum(["train", "validation", "frozen_eval"])
 }).passthrough();
-var TrainingEvaluationSourceSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingEvaluationSource.v1"),
+var TrainingEvaluationSourceSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingEvaluationSource.v1"),
   taskset: ModelProjectVersionedRefSchema,
-  tasks: z2.array(TaskIdentitySchema).min(1).max(1e4),
-  assets: z2.array(z2.object({
-    path: z2.string().trim().min(1).max(2e3),
-    sha256: z2.string().regex(/^[a-f0-9]{64}$/),
-    sizeBytes: z2.number().int().nonnegative(),
-    encoding: z2.literal("base64"),
-    content: z2.string().max(32 * 1024 * 1024)
+  tasks: z3.array(TaskIdentitySchema).min(1).max(1e4),
+  assets: z3.array(z3.object({
+    path: z3.string().trim().min(1).max(2e3),
+    sha256: z3.string().regex(/^[a-f0-9]{64}$/),
+    sizeBytes: z3.number().int().nonnegative(),
+    encoding: z3.literal("base64"),
+    content: z3.string().max(32 * 1024 * 1024)
   }).strict()).max(1e4)
 }).strict().superRefine((source, context) => {
   const ids = /* @__PURE__ */ new Set();
@@ -66,8 +132,8 @@ var TrainingEvaluationSourceSchema = z2.object({
   });
 });
 function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
-  const training = z2.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
-  const evaluation = z2.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
+  const training = z3.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
+  const evaluation = z3.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
   const trainIds = /* @__PURE__ */ new Set();
   const trainFamilies = /* @__PURE__ */ new Set();
   for (const task of training) {
@@ -93,24 +159,24 @@ async function trainingEvaluationSourceRef(input) {
 }
 
 // src/training.ts
-var IdSchema = z3.string().trim().min(1).max(500);
-var HashSchema = z3.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z3.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z3.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z3.string().trim().min(1).max(500),
+var IdSchema2 = z4.string().trim().min(1).max(500);
+var HashSchema2 = z4.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema = z4.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z4.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z4.string().trim().min(1).max(500),
   sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z3.unknown(),
-  contentHash: HashSchema
+  payload: z4.unknown(),
+  contentHash: HashSchema2
 }).strict();
-var TrainingInputArtifactSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingInputArtifact.v2"),
-  kind: z3.enum(["portable_training_bundle", "reward_model_dataset"]),
+var TrainingInputArtifactSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingInputArtifact.v2"),
+  kind: z4.enum(["portable_training_bundle", "reward_model_dataset"]),
   sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z3.string().trim().min(1).max(2e3),
-  contentHash: HashSchema,
-  sizeBytes: z3.number().int().positive(),
+  artifactRef: z4.string().trim().min(1).max(2e3),
+  contentHash: HashSchema2,
+  sizeBytes: z4.number().int().positive(),
   createdAt: TimestampSchema
 }).strict();
 async function trainingInputArtifactUploadHash(upload) {
@@ -133,11 +199,11 @@ async function parseAndVerifyTrainingInputArtifactUpload(value) {
   }
   return parsed;
 }
-var TrainingJobKindSchema = z3.enum([
+var TrainingJobKindSchema = z4.enum([
   "reward_model_train",
   "policy_optimize"
 ]);
-var TrainingJobStateSchema = z3.enum([
+var TrainingJobStateSchema = z4.enum([
   "queued",
   "admitting",
   "provisioning",
@@ -148,94 +214,94 @@ var TrainingJobStateSchema = z3.enum([
   "failed",
   "cancelled"
 ]);
-var TrainingCapabilityRequirementSchema = z3.object({
-  id: IdSchema,
-  version: z3.string().trim().min(1).max(200).nullable().default(null),
-  required: z3.boolean().default(true)
+var TrainingCapabilityRequirementSchema = z4.object({
+  id: IdSchema2,
+  version: z4.string().trim().min(1).max(200).nullable().default(null),
+  required: z4.boolean().default(true)
 }).strict();
-var TrainingJobSourceSchema = z3.object({
-  modelProject: z3.object({
-    id: IdSchema,
-    portableProjectId: IdSchema,
-    revision: z3.number().int().positive(),
-    contentHash: HashSchema
+var TrainingJobSourceSchema = z4.object({
+  modelProject: z4.object({
+    id: IdSchema2,
+    portableProjectId: IdSchema2,
+    revision: z4.number().int().positive(),
+    contentHash: HashSchema2
   }).strict(),
   harnessRunManifest: ModelProjectImmutableRefSchema,
   harnessRelease: ModelProjectImmutableRefSchema,
   taskset: ModelProjectVersionedRefSchema,
   tasksetRelease: ModelProjectImmutableRefSchema,
-  evaluation: z3.object({
+  evaluation: z4.object({
     taskset: ModelProjectVersionedRefSchema,
     dataset: ModelProjectImmutableRefSchema
   }).strict().nullable().optional(),
   dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z3.array(ModelProjectImmutableRefSchema).max(1e4)
+  evidenceSets: z4.array(ModelProjectImmutableRefSchema).max(1e4)
 }).strict();
-var RewardModelTrainingRequestSchema = z3.object({
-  kind: z3.literal("reward_model_train"),
+var RewardModelTrainingRequestSchema = z4.object({
+  kind: z4.literal("reward_model_train"),
   baseModel: ModelProjectBaseModelSchema,
   preferenceDatasetRelease: ModelProjectImmutableRefSchema,
   processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z3.object({
-    schemaVersion: z3.literal("openpond.rewardModelRecipe.v1"),
-    method: z3.literal("reward_model"),
-    parameterization: z3.literal("lora_with_scalar_head")
-  }).catchall(z3.unknown())
+  recipe: z4.object({
+    schemaVersion: z4.literal("openpond.rewardModelRecipe.v1"),
+    method: z4.literal("reward_model"),
+    parameterization: z4.literal("lora_with_scalar_head")
+  }).catchall(z4.unknown())
 }).strict();
-var DeterministicRewardSourceSchema = z3.object({
-  kind: z3.literal("deterministic"),
+var DeterministicRewardSourceSchema = z4.object({
+  kind: z4.literal("deterministic"),
   grader: ModelProjectImmutableRefSchema,
   composer: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var LearnedRewardSourceSchema = z3.object({
-  kind: z3.literal("learned_reward"),
+var LearnedRewardSourceSchema = z4.object({
+  kind: z4.literal("learned_reward"),
   rewardModelVersion: ModelProjectImmutableRefSchema,
   qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z3.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z3.object({
-    artifactRef: z3.string().trim().min(1).max(2e3),
-    contentHash: HashSchema,
+  evaluationReferences: z4.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z4.object({
+    artifactRef: z4.string().trim().min(1).max(2e3),
+    contentHash: HashSchema2,
     executionReceipt: ModelProjectImmutableRefSchema
   }).strict(),
   processorRelease: ModelProjectImmutableRefSchema,
   rewardComposerRelease: ModelProjectImmutableRefSchema
 }).strict();
-var PolicyOptimizationRequestSchema = z3.object({
-  kind: z3.literal("policy_optimize"),
+var PolicyOptimizationRequestSchema = z4.object({
+  kind: z4.literal("policy_optimize"),
   baseModel: ModelProjectBaseModelSchema,
   recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z3.discriminatedUnion("kind", [
+  rewardSource: z4.discriminatedUnion("kind", [
     DeterministicRewardSourceSchema,
     LearnedRewardSourceSchema
   ]),
   resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var TrainingJobRequestSchema = z3.discriminatedUnion("kind", [
+var TrainingJobRequestSchema = z4.discriminatedUnion("kind", [
   RewardModelTrainingRequestSchema,
   PolicyOptimizationRequestSchema
 ]);
-var TrainingJobApprovalSchema = z3.object({
-  approvalHash: HashSchema,
+var TrainingJobApprovalSchema = z4.object({
+  approvalHash: HashSchema2,
   approvedAt: TimestampSchema,
-  exportApproved: z3.boolean(),
-  maximumSpendUsd: z3.number().nonnegative(),
-  retentionDays: z3.number().int().nonnegative().nullable(),
-  region: z3.string().trim().min(1).max(200).nullable().default(null)
+  exportApproved: z4.boolean(),
+  maximumSpendUsd: z4.number().nonnegative(),
+  retentionDays: z4.number().int().nonnegative().nullable(),
+  region: z4.string().trim().min(1).max(200).nullable().default(null)
 }).strict();
-var TrainingJobSubmissionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z3.string().trim().min(1).max(500),
-  name: z3.string().trim().min(1).max(200),
+var TrainingJobSubmissionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z4.string().trim().min(1).max(500),
+  name: z4.string().trim().min(1).max(200),
   source: TrainingJobSourceSchema,
   job: TrainingJobRequestSchema,
-  requestedCapabilities: z3.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z3.enum(["fast", "balanced", "economical"]),
-  budget: z3.object({
-    maximumSpendUsd: z3.number().nonnegative(),
-    maximumWallSeconds: z3.number().int().positive()
+  requestedCapabilities: z4.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z4.enum(["fast", "balanced", "economical"]),
+  budget: z4.object({
+    maximumSpendUsd: z4.number().nonnegative(),
+    maximumWallSeconds: z4.number().int().positive()
   }).strict(),
   approval: TrainingJobApprovalSchema,
-  contentHash: HashSchema
+  contentHash: HashSchema2
 }).strict().superRefine((submission, context) => {
   if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
     context.addIssue({
@@ -265,61 +331,61 @@ async function parseAndVerifyTrainingJobSubmission(value) {
   }
   return parsed;
 }
-var TrainingJobSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJob.v2"),
-  id: IdSchema,
-  teamId: IdSchema,
+var TrainingJobSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJob.v2"),
+  id: IdSchema2,
+  teamId: IdSchema2,
   kind: TrainingJobKindSchema,
-  modelProjectId: IdSchema,
-  portableProjectId: IdSchema,
-  sourceProjectRevision: z3.number().int().positive(),
-  submissionHash: HashSchema,
+  modelProjectId: IdSchema2,
+  portableProjectId: IdSchema2,
+  sourceProjectRevision: z4.number().int().positive(),
+  submissionHash: HashSchema2,
   state: TrainingJobStateSchema,
-  phase: z3.string().trim().min(1).max(200),
-  version: z3.number().int().nonnegative(),
-  progress: z3.number().min(0).max(1),
-  rolloutProgress: z3.object({
-    groupsCompleted: z3.number().int().nonnegative(),
-    groupsTarget: z3.number().int().nonnegative(),
-    optimizerUpdatesApplied: z3.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z3.number().int().nonnegative()
+  phase: z4.string().trim().min(1).max(200),
+  version: z4.number().int().nonnegative(),
+  progress: z4.number().min(0).max(1),
+  rolloutProgress: z4.object({
+    groupsCompleted: z4.number().int().nonnegative(),
+    groupsTarget: z4.number().int().nonnegative(),
+    optimizerUpdatesApplied: z4.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z4.number().int().nonnegative()
   }).strict(),
-  accruedSpendUsd: z3.number().nonnegative(),
-  terminalReason: z3.string().trim().min(1).max(5e3).nullable(),
+  accruedSpendUsd: z4.number().nonnegative(),
+  terminalReason: z4.string().trim().min(1).max(5e3).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema,
   completedAt: TimestampSchema.nullable()
 }).strict();
-var TrainingJobPageSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJobPage.v2"),
-  jobs: z3.array(TrainingJobSchema).max(1e3),
-  nextCursor: z3.string().trim().min(1).max(2e3).nullable()
+var TrainingJobPageSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJobPage.v2"),
+  jobs: z4.array(TrainingJobSchema).max(1e3),
+  nextCursor: z4.string().trim().min(1).max(2e3).nullable()
 }).strict();
-var TrainingJobEventSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJobEvent.v2"),
-  id: IdSchema,
-  jobId: IdSchema,
-  sequence: z3.number().int().nonnegative(),
-  type: IdSchema,
-  phase: z3.string().trim().min(1).max(200),
-  message: z3.string().trim().min(1).max(5e3).nullable(),
-  data: z3.record(z3.string(), z3.unknown()).default({}),
+var TrainingJobEventSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJobEvent.v2"),
+  id: IdSchema2,
+  jobId: IdSchema2,
+  sequence: z4.number().int().nonnegative(),
+  type: IdSchema2,
+  phase: z4.string().trim().min(1).max(200),
+  message: z4.string().trim().min(1).max(5e3).nullable(),
+  data: z4.record(z4.string(), z4.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobLogSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJobLog.v2"),
-  jobId: IdSchema,
-  sequence: z3.number().int().nonnegative(),
-  level: z3.enum(["debug", "info", "warning", "error"]),
-  message: z3.string().max(2e4),
+var TrainingJobLogSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJobLog.v2"),
+  jobId: IdSchema2,
+  sequence: z4.number().int().nonnegative(),
+  level: z4.enum(["debug", "info", "warning", "error"]),
+  message: z4.string().max(2e4),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobControlRequestSchema = z3.object({ expectedVersion: z3.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJobOutput.v2"),
-  id: IdSchema,
-  jobId: IdSchema,
-  kind: z3.enum([
+var TrainingJobControlRequestSchema = z4.object({ expectedVersion: z4.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJobOutput.v2"),
+  id: IdSchema2,
+  jobId: IdSchema2,
+  kind: z4.enum([
     "checkpoint",
     "adapter",
     "scorer",
@@ -328,38 +394,38 @@ var TrainingJobOutputSchema = z3.object({
     "trace",
     "receipt"
   ]),
-  artifactRef: z3.string().trim().min(1).max(2e3),
-  contentHash: HashSchema,
-  sizeBytes: z3.number().int().nonnegative(),
-  metadata: z3.record(z3.string(), z3.unknown()).default({}),
+  artifactRef: z4.string().trim().min(1).max(2e3),
+  contentHash: HashSchema2,
+  sizeBytes: z4.number().int().nonnegative(),
+  metadata: z4.record(z4.string(), z4.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingExecutionReceiptSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingExecutionReceipt.v2"),
-  id: IdSchema,
-  teamId: IdSchema,
-  jobId: IdSchema,
-  submissionHash: HashSchema,
-  manifestHash: HashSchema,
-  recipeHash: HashSchema,
-  capabilityHash: HashSchema,
+var TrainingExecutionReceiptSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingExecutionReceipt.v2"),
+  id: IdSchema2,
+  teamId: IdSchema2,
+  jobId: IdSchema2,
+  submissionHash: HashSchema2,
+  manifestHash: HashSchema2,
+  recipeHash: HashSchema2,
+  capabilityHash: HashSchema2,
   runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z3.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z3.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z3.number().nonnegative(),
-  durationSeconds: z3.number().nonnegative(),
-  cleanupComplete: z3.boolean(),
-  issuer: IdSchema,
+  inputs: z4.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z4.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z4.number().nonnegative(),
+  durationSeconds: z4.number().nonnegative(),
+  cleanupComplete: z4.boolean(),
+  issuer: IdSchema2,
   issuedAt: TimestampSchema,
-  signature: z3.string().trim().min(1).max(1e4).nullable()
+  signature: z4.string().trim().min(1).max(1e4).nullable()
 }).strict();
 async function trainingExecutionReceiptHash(receipt) {
   return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
 }
 async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
   const receipt = TrainingExecutionReceiptSchema.parse(value);
-  const expectedId = IdSchema.parse(expected.id);
-  const expectedHash = HashSchema.parse(expected.contentHash);
+  const expectedId = IdSchema2.parse(expected.id);
+  const expectedHash = HashSchema2.parse(expected.contentHash);
   const actualHash = await trainingExecutionReceiptHash(receipt);
   if (receipt.id !== expectedId || actualHash !== expectedHash) {
     throw new OpenPondProtocolError(
@@ -367,13 +433,13 @@ async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
       "The execution receipt identity or canonical content hash did not match."
     );
   }
-  if (expected.teamId !== void 0 && receipt.teamId !== IdSchema.parse(expected.teamId)) {
+  if (expected.teamId !== void 0 && receipt.teamId !== IdSchema2.parse(expected.teamId)) {
     throw new OpenPondProtocolError(
       "execution_receipt_team_mismatch",
       "The execution receipt belongs to a different team."
     );
   }
-  if (expected.jobId !== void 0 && receipt.jobId !== IdSchema.parse(expected.jobId)) {
+  if (expected.jobId !== void 0 && receipt.jobId !== IdSchema2.parse(expected.jobId)) {
     throw new OpenPondProtocolError(
       "execution_receipt_job_mismatch",
       "The execution receipt belongs to a different Training Job."
@@ -387,18 +453,18 @@ async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
   }
   return receipt;
 }
-var TrainingJobOutputsSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z3.array(TrainingJobOutputSchema).max(1e4),
+var TrainingJobOutputsSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z4.array(TrainingJobOutputSchema).max(1e4),
   receipt: TrainingExecutionReceiptSchema.nullable()
 }).strict();
-var TrainingApiErrorSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingApiError.v2"),
-  code: z3.string().trim().min(1).max(200),
-  message: z3.string().trim().min(1).max(5e3),
-  retryable: z3.boolean().default(false),
-  requestId: z3.string().trim().min(1).max(500).nullable().default(null),
-  details: z3.record(z3.string(), z3.unknown()).default({})
+var TrainingApiErrorSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingApiError.v2"),
+  code: z4.string().trim().min(1).max(200),
+  message: z4.string().trim().min(1).max(5e3),
+  retryable: z4.boolean().default(false),
+  requestId: z4.string().trim().min(1).max(500).nullable().default(null),
+  details: z4.record(z4.string(), z4.unknown()).default({})
 }).strict();
 var OpenPondTrainingApiError = class extends Error {
   status;
@@ -416,23 +482,23 @@ var OpenPondTrainingApiError = class extends Error {
     this.details = error.details;
   }
 };
-var TrainingCapabilitiesSchema = z3.object({
-  schemaVersion: z3.literal("openpond.trainingCapabilities.v2"),
-  capabilityHash: HashSchema,
-  jobKinds: z3.array(TrainingJobKindSchema),
-  methods: z3.array(z3.string().trim().min(1).max(200)),
-  placements: z3.array(
-    z3.enum(["local", "remote", "colocated", "provider_native"])
+var TrainingCapabilitiesSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingCapabilities.v2"),
+  capabilityHash: HashSchema2,
+  jobKinds: z4.array(TrainingJobKindSchema),
+  methods: z4.array(z4.string().trim().min(1).max(200)),
+  placements: z4.array(
+    z4.enum(["local", "remote", "colocated", "provider_native"])
   ),
-  controls: z3.object({
-    cancel: z3.boolean(),
-    stopAfterGroup: z3.boolean(),
-    resumeFromCheckpoint: z3.boolean()
+  controls: z4.object({
+    cancel: z4.boolean(),
+    stopAfterGroup: z4.boolean(),
+    resumeFromCheckpoint: z4.boolean()
   }).strict(),
-  limits: z3.object({
-    maximumSpendUsd: z3.number().nonnegative(),
-    maximumWallSeconds: z3.number().int().positive(),
-    maximumArtifactBytes: z3.number().int().positive()
+  limits: z4.object({
+    maximumSpendUsd: z4.number().nonnegative(),
+    maximumWallSeconds: z4.number().int().positive(),
+    maximumArtifactBytes: z4.number().int().positive()
   }).strict(),
   checkedAt: TimestampSchema,
   expiresAt: TimestampSchema
@@ -520,15 +586,15 @@ function createTrainingClient(input) {
     async listJobs(options = {}) {
       const parameters = new URLSearchParams();
       if (options.modelProjectId) {
-        parameters.set("modelProjectId", IdSchema.parse(options.modelProjectId));
+        parameters.set("modelProjectId", IdSchema2.parse(options.modelProjectId));
       }
       if (options.cursor) {
-        parameters.set("cursor", z3.string().trim().min(1).max(2e3).parse(options.cursor));
+        parameters.set("cursor", z4.string().trim().min(1).max(2e3).parse(options.cursor));
       }
       if (options.limit !== void 0) {
         parameters.set(
           "limit",
-          String(z3.number().int().min(1).max(1e3).parse(options.limit))
+          String(z4.number().int().min(1).max(1e3).parse(options.limit))
         );
       }
       const query = parameters.size > 0 ? `?${parameters.toString()}` : "";
@@ -539,7 +605,7 @@ function createTrainingClient(input) {
     async getJob(jobId) {
       return TrainingJobSchema.parse(
         unwrapObject(
-          await request(`/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}`),
+          await request(`/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}`),
           "job"
         )
       );
@@ -549,7 +615,7 @@ function createTrainingClient(input) {
       return TrainingJobSchema.parse(
         unwrapObject(
           await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/cancel`,
+            `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/cancel`,
             { method: "POST", body: JSON.stringify(control) }
           ),
           "job"
@@ -561,7 +627,7 @@ function createTrainingClient(input) {
       return TrainingJobSchema.parse(
         unwrapObject(
           await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/stop-after-group`,
+            `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/stop-after-group`,
             { method: "POST", body: JSON.stringify(control) }
           ),
           "job"
@@ -569,10 +635,10 @@ function createTrainingClient(input) {
       );
     },
     async events(jobId) {
-      return z3.array(TrainingJobEventSchema).parse(
+      return z4.array(TrainingJobEventSchema).parse(
         unwrapObject(
           await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/events`
+            `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/events`
           ),
           "events"
         )
@@ -581,15 +647,29 @@ function createTrainingClient(input) {
     async outputs(jobId) {
       return TrainingJobOutputsSchema.parse(
         await request(
-          `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/outputs`
+          `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/outputs`
         )
       );
     },
+    async evaluationTasks(jobId, evaluation, options = {}) {
+      const id = IdSchema2.parse(jobId);
+      const reference = ModelProjectImmutableRefSchema.parse(evaluation);
+      const parameters = new URLSearchParams();
+      const cursor = options.cursor === void 0 ? void 0 : z4.string().regex(/^[1-9]\d*$/).parse(options.cursor);
+      const offset = cursor === void 0 ? 0 : z4.number().int().min(1).max(9999).parse(Number(cursor));
+      if (cursor !== void 0) parameters.set("cursor", cursor);
+      if (options.limit !== void 0) parameters.set("limit", String(z4.number().int().min(1).max(100).parse(options.limit)));
+      const query = parameters.size ? `?${parameters.toString()}` : "";
+      return parseAndVerifyTrainingEvaluationTaskPage(
+        await request(`/v1/training/jobs/${encodeURIComponent(id)}/evaluations/${encodeURIComponent(reference.id)}/tasks${query}`),
+        { jobId: id, evaluation: reference, offset }
+      );
+    },
     async logs(jobId) {
-      return z3.array(TrainingJobLogSchema).max(1e5).parse(
+      return z4.array(TrainingJobLogSchema).max(1e5).parse(
         unwrapObject(
           await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/logs`
+            `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/logs`
           ),
           "logs"
         )
@@ -623,6 +703,10 @@ function trainingApiError(value, status) {
 }
 
 export {
+  TrainingEvaluationTaskResultSchema,
+  TrainingEvaluationTaskPageSchema,
+  trainingEvaluationTaskPageHash,
+  parseAndVerifyTrainingEvaluationTaskPage,
   deterministicTrainingRewardSource,
   TRAINING_EVALUATION_SOURCE_PATH,
   TrainingEvaluationSourceSchema,
@@ -658,4 +742,4 @@ export {
   TrainingCapabilitiesSchema,
   createTrainingClient
 };
-//# sourceMappingURL=chunk-OJERFIEJ.js.map
+//# sourceMappingURL=chunk-36A46YZX.js.map