openpond-sdk 0.5.0 → 0.5.2

package/TRAINING_PROTOCOL.md

@@ -78,6 +78,44 @@ checkpoint inventory or qualification metrics, when the portable client needs
 that evidence to validate the artifact. This metadata is immutable output
 evidence, not private worker-control, lease, or provider state.
 
+## Deterministic grading identity
+
+For portable training bundles, derive `job.rewardSource` with
+`deterministicTrainingRewardSource({ graders, rewardExecution })` from the
+verified bundle's `graders.json` and optional `reward-binding.json`. The grader
+reference identifies the entire ordered set, including configuration, using the
+canonical hash of `{ schemaVersion: "openpond.trainingGraderSet.v1", graders }`.
+Its ID is `training-graders-` followed by the first 32 hash characters.
+
+When a Reward binding exists, the helper compiles its verified releases to the
+executed grader set and uses the binding's immutable ID/hash as `composer`.
+This pins role, normalization, membership, weights, required sources and hard
+gates even when those changes leave grader code unchanged. An unbound plan has
+a null composer. Providers must recompute both references from the admitted
+bundle before provisioning and retain both in receipt inputs when non-null.
+Identity validation does not establish that a provider can execute a grader;
+providers must also reject unsupported execution configurations at admission.
+
+## Held-out evaluation source
+
+Managed policy training carries `evaluation-source.json` inside the verified
+resolved bundle. `TrainingEvaluationSourceSchema` describes its exact Taskset
+revision, complete held-out task records and evaluator-only asset bytes.
+`assertTrainingEvaluationIsolation` rejects train/held-out split violations,
+duplicate task IDs and shared training/evaluation families. The data remains
+private to evaluation and must not become policy-visible context.
+
+`trainingEvaluationSourceRef` derives `source.evaluation`: the original Taskset
+reference and the canonical evaluation dataset hash. Providers compare these
+references with the admitted bundle before provisioning and retain both in
+receipt inputs. Changing private answers or assets changes the bundle and
+evaluation dataset identity. Model configuration may select a separate immutable
+`evaluationTasksetRef`; a train-only batch does not need a Comparison Series.
+
+The nullable wire field preserves historical records. A provider that requires
+pinned evaluation must reject new policy submissions without it. Artifact
+admission alone does not establish model execution or learning quality.
+
 ## Conformance
 
 Published fixtures live in `fixtures/training/v2`. Providers should:

package/dist/{chunk-65D4C7HP.js → chunk-4IDTRFW2.js}

@@ -1,7 +1,7 @@
 import {
   ModelProjectVersionedRefSchema,
   canonicalJson
-} from "./chunk-5PRP457R.js";
+} from "./chunk-ZNFOVV7B.js";
 
 // src/model-starter-execution.ts
 import { z } from "zod";
@@ -270,4 +270,4 @@ export {
   deriveModelTaskset,
   validateModelTasksetPackage
 };
-//# sourceMappingURL=chunk-65D4C7HP.js.map
+//# sourceMappingURL=chunk-4IDTRFW2.js.map

package/dist/{chunk-747CMU2Y.js → chunk-6QWV5TEJ.js}

@@ -1,13 +1,13 @@
 import {
   ModelStarterExecutionSchema,
   validateModelStarterExecution
-} from "./chunk-65D4C7HP.js";
+} from "./chunk-4IDTRFW2.js";
 import {
   ModelProjectBaseModelSchema,
   ModelProjectTrainingMethodSchema,
   ModelProjectVersionedRefSchema,
   canonicalSha256
-} from "./chunk-5PRP457R.js";
+} from "./chunk-ZNFOVV7B.js";
 
 // src/model-starters.ts
 import { z } from "zod";
@@ -219,4 +219,4 @@ export {
   previewModelStarter,
   validateResolvedModelStarter
 };
-//# sourceMappingURL=chunk-747CMU2Y.js.map
+//# sourceMappingURL=chunk-6QWV5TEJ.js.map

package/dist/{chunk-AVW35YOH.js → chunk-OJERFIEJ.js}

@@ -11,28 +11,106 @@ import {
   assertCanonicalPayloadSize,
   canonicalSha256,
   parseBoundedJson
-} from "./chunk-5PRP457R.js";
+} from "./chunk-ZNFOVV7B.js";
 
 // src/training.ts
+import { z as z3 } from "zod";
+
+// src/training-grading-plan.ts
 import { z } from "zod";
-var IdSchema = z.string().trim().min(1).max(500);
-var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z.string().trim().min(1).max(500),
+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({
+  binding: RewardBindingSchema,
+  rewards: z.array(RewardReleaseSchema).min(1).max(100)
+}).strict();
+async function deterministicTrainingRewardSource(input) {
+  const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
+  const graders = GradersSchema.parse(execution ? compileBoundGraders(execution.binding, execution.rewards) : input.graders);
+  if (new Set(graders.map((grader) => grader.id)).size !== graders.length) {
+    throw new Error("Training grader identities must be unique.");
+  }
+  const hash = await canonicalSha256({ schemaVersion: "openpond.trainingGraderSet.v1", graders });
+  return {
+    kind: "deterministic",
+    grader: { id: `training-graders-${hash.slice(0, 32)}`, contentHash: hash },
+    composer: execution ? { id: execution.binding.id, contentHash: execution.binding.contentHash } : null
+  };
+}
+
+// src/training-evaluation-source.ts
+import { z as z2 } 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"])
+}).passthrough();
+var TrainingEvaluationSourceSchema = z2.object({
+  schemaVersion: z2.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)
+  }).strict()).max(1e4)
+}).strict().superRefine((source, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  source.tasks.forEach((task, index) => {
+    if (task.split === "train") context.addIssue({ code: "custom", path: ["tasks", index, "split"], message: "Evaluation sources require held-out tasks." });
+    if (ids.has(task.id)) context.addIssue({ code: "custom", path: ["tasks", index, "id"], message: "Evaluation task identities must be unique." });
+    ids.add(task.id);
+  });
+});
+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 trainIds = /* @__PURE__ */ new Set();
+  const trainFamilies = /* @__PURE__ */ new Set();
+  for (const task of training) {
+    if (task.split !== "train") throw new Error("The training population contains a held-out task.");
+    if (trainIds.has(task.id)) throw new Error("Training task identities must be unique.");
+    trainIds.add(task.id);
+    trainFamilies.add(task.clusterKey);
+  }
+  const evaluationIds = /* @__PURE__ */ new Set();
+  for (const task of evaluation) {
+    if (task.split === "train") throw new Error("The evaluation population contains a training task.");
+    if (evaluationIds.has(task.id)) throw new Error("Evaluation task identities must be unique.");
+    if (trainIds.has(task.id) || trainFamilies.has(task.clusterKey)) {
+      throw new Error("Training and evaluation tasks or families overlap.");
+    }
+    evaluationIds.add(task.id);
+  }
+}
+async function trainingEvaluationSourceRef(input) {
+  const source = TrainingEvaluationSourceSchema.parse(input);
+  const hash = await canonicalSha256(source);
+  return { taskset: source.taskset, dataset: { id: `training-evaluation-${hash.slice(0, 32)}`, contentHash: hash } };
+}
+
+// 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),
   sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z.unknown(),
+  payload: z3.unknown(),
   contentHash: HashSchema
 }).strict();
-var TrainingInputArtifactSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingInputArtifact.v2"),
-  kind: z.enum(["portable_training_bundle", "reward_model_dataset"]),
+var TrainingInputArtifactSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingInputArtifact.v2"),
+  kind: z3.enum(["portable_training_bundle", "reward_model_dataset"]),
   sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z.string().trim().min(1).max(2e3),
+  artifactRef: z3.string().trim().min(1).max(2e3),
   contentHash: HashSchema,
-  sizeBytes: z.number().int().positive(),
+  sizeBytes: z3.number().int().positive(),
   createdAt: TimestampSchema
 }).strict();
 async function trainingInputArtifactUploadHash(upload) {
@@ -55,11 +133,11 @@ async function parseAndVerifyTrainingInputArtifactUpload(value) {
   }
   return parsed;
 }
-var TrainingJobKindSchema = z.enum([
+var TrainingJobKindSchema = z3.enum([
   "reward_model_train",
   "policy_optimize"
 ]);
-var TrainingJobStateSchema = z.enum([
+var TrainingJobStateSchema = z3.enum([
   "queued",
   "admitting",
   "provisioning",
@@ -70,87 +148,91 @@ var TrainingJobStateSchema = z.enum([
   "failed",
   "cancelled"
 ]);
-var TrainingCapabilityRequirementSchema = z.object({
+var TrainingCapabilityRequirementSchema = z3.object({
   id: IdSchema,
-  version: z.string().trim().min(1).max(200).nullable().default(null),
-  required: z.boolean().default(true)
+  version: z3.string().trim().min(1).max(200).nullable().default(null),
+  required: z3.boolean().default(true)
 }).strict();
-var TrainingJobSourceSchema = z.object({
-  modelProject: z.object({
+var TrainingJobSourceSchema = z3.object({
+  modelProject: z3.object({
     id: IdSchema,
     portableProjectId: IdSchema,
-    revision: z.number().int().positive(),
+    revision: z3.number().int().positive(),
     contentHash: HashSchema
   }).strict(),
   harnessRunManifest: ModelProjectImmutableRefSchema,
   harnessRelease: ModelProjectImmutableRefSchema,
   taskset: ModelProjectVersionedRefSchema,
   tasksetRelease: ModelProjectImmutableRefSchema,
+  evaluation: z3.object({
+    taskset: ModelProjectVersionedRefSchema,
+    dataset: ModelProjectImmutableRefSchema
+  }).strict().nullable().optional(),
   dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z.array(ModelProjectImmutableRefSchema).max(1e4)
+  evidenceSets: z3.array(ModelProjectImmutableRefSchema).max(1e4)
 }).strict();
-var RewardModelTrainingRequestSchema = z.object({
-  kind: z.literal("reward_model_train"),
+var RewardModelTrainingRequestSchema = z3.object({
+  kind: z3.literal("reward_model_train"),
   baseModel: ModelProjectBaseModelSchema,
   preferenceDatasetRelease: ModelProjectImmutableRefSchema,
   processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z.object({
-    schemaVersion: z.literal("openpond.rewardModelRecipe.v1"),
-    method: z.literal("reward_model"),
-    parameterization: z.literal("lora_with_scalar_head")
-  }).catchall(z.unknown())
+  recipe: z3.object({
+    schemaVersion: z3.literal("openpond.rewardModelRecipe.v1"),
+    method: z3.literal("reward_model"),
+    parameterization: z3.literal("lora_with_scalar_head")
+  }).catchall(z3.unknown())
 }).strict();
-var DeterministicRewardSourceSchema = z.object({
-  kind: z.literal("deterministic"),
+var DeterministicRewardSourceSchema = z3.object({
+  kind: z3.literal("deterministic"),
   grader: ModelProjectImmutableRefSchema,
   composer: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var LearnedRewardSourceSchema = z.object({
-  kind: z.literal("learned_reward"),
+var LearnedRewardSourceSchema = z3.object({
+  kind: z3.literal("learned_reward"),
   rewardModelVersion: ModelProjectImmutableRefSchema,
   qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z.object({
-    artifactRef: z.string().trim().min(1).max(2e3),
+  evaluationReferences: z3.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z3.object({
+    artifactRef: z3.string().trim().min(1).max(2e3),
     contentHash: HashSchema,
     executionReceipt: ModelProjectImmutableRefSchema
   }).strict(),
   processorRelease: ModelProjectImmutableRefSchema,
   rewardComposerRelease: ModelProjectImmutableRefSchema
 }).strict();
-var PolicyOptimizationRequestSchema = z.object({
-  kind: z.literal("policy_optimize"),
+var PolicyOptimizationRequestSchema = z3.object({
+  kind: z3.literal("policy_optimize"),
   baseModel: ModelProjectBaseModelSchema,
   recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z.discriminatedUnion("kind", [
+  rewardSource: z3.discriminatedUnion("kind", [
     DeterministicRewardSourceSchema,
     LearnedRewardSourceSchema
   ]),
   resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var TrainingJobRequestSchema = z.discriminatedUnion("kind", [
+var TrainingJobRequestSchema = z3.discriminatedUnion("kind", [
   RewardModelTrainingRequestSchema,
   PolicyOptimizationRequestSchema
 ]);
-var TrainingJobApprovalSchema = z.object({
+var TrainingJobApprovalSchema = z3.object({
   approvalHash: HashSchema,
   approvedAt: TimestampSchema,
-  exportApproved: z.boolean(),
-  maximumSpendUsd: z.number().nonnegative(),
-  retentionDays: z.number().int().nonnegative().nullable(),
-  region: z.string().trim().min(1).max(200).nullable().default(null)
+  exportApproved: z3.boolean(),
+  maximumSpendUsd: z3.number().nonnegative(),
+  retentionDays: z3.number().int().nonnegative().nullable(),
+  region: z3.string().trim().min(1).max(200).nullable().default(null)
 }).strict();
-var TrainingJobSubmissionSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z.string().trim().min(1).max(500),
-  name: z.string().trim().min(1).max(200),
+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),
   source: TrainingJobSourceSchema,
   job: TrainingJobRequestSchema,
-  requestedCapabilities: z.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z.enum(["fast", "balanced", "economical"]),
-  budget: z.object({
-    maximumSpendUsd: z.number().nonnegative(),
-    maximumWallSeconds: z.number().int().positive()
+  requestedCapabilities: z3.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z3.enum(["fast", "balanced", "economical"]),
+  budget: z3.object({
+    maximumSpendUsd: z3.number().nonnegative(),
+    maximumWallSeconds: z3.number().int().positive()
   }).strict(),
   approval: TrainingJobApprovalSchema,
   contentHash: HashSchema
@@ -183,61 +265,61 @@ async function parseAndVerifyTrainingJobSubmission(value) {
   }
   return parsed;
 }
-var TrainingJobSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJob.v2"),
+var TrainingJobSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingJob.v2"),
   id: IdSchema,
   teamId: IdSchema,
   kind: TrainingJobKindSchema,
   modelProjectId: IdSchema,
   portableProjectId: IdSchema,
-  sourceProjectRevision: z.number().int().positive(),
+  sourceProjectRevision: z3.number().int().positive(),
   submissionHash: HashSchema,
   state: TrainingJobStateSchema,
-  phase: z.string().trim().min(1).max(200),
-  version: z.number().int().nonnegative(),
-  progress: z.number().min(0).max(1),
-  rolloutProgress: z.object({
-    groupsCompleted: z.number().int().nonnegative(),
-    groupsTarget: z.number().int().nonnegative(),
-    optimizerUpdatesApplied: z.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z.number().int().nonnegative()
+  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()
   }).strict(),
-  accruedSpendUsd: z.number().nonnegative(),
-  terminalReason: z.string().trim().min(1).max(5e3).nullable(),
+  accruedSpendUsd: z3.number().nonnegative(),
+  terminalReason: z3.string().trim().min(1).max(5e3).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema,
   completedAt: TimestampSchema.nullable()
 }).strict();
-var TrainingJobPageSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJobPage.v2"),
-  jobs: z.array(TrainingJobSchema).max(1e3),
-  nextCursor: z.string().trim().min(1).max(2e3).nullable()
+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()
 }).strict();
-var TrainingJobEventSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJobEvent.v2"),
+var TrainingJobEventSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingJobEvent.v2"),
   id: IdSchema,
   jobId: IdSchema,
-  sequence: z.number().int().nonnegative(),
+  sequence: z3.number().int().nonnegative(),
   type: IdSchema,
-  phase: z.string().trim().min(1).max(200),
-  message: z.string().trim().min(1).max(5e3).nullable(),
-  data: z.record(z.string(), z.unknown()).default({}),
+  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({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobLogSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJobLog.v2"),
+var TrainingJobLogSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingJobLog.v2"),
   jobId: IdSchema,
-  sequence: z.number().int().nonnegative(),
-  level: z.enum(["debug", "info", "warning", "error"]),
-  message: z.string().max(2e4),
+  sequence: z3.number().int().nonnegative(),
+  level: z3.enum(["debug", "info", "warning", "error"]),
+  message: z3.string().max(2e4),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobControlRequestSchema = z.object({ expectedVersion: z.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJobOutput.v2"),
+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: z.enum([
+  kind: z3.enum([
     "checkpoint",
     "adapter",
     "scorer",
@@ -246,14 +328,14 @@ var TrainingJobOutputSchema = z.object({
     "trace",
     "receipt"
   ]),
-  artifactRef: z.string().trim().min(1).max(2e3),
+  artifactRef: z3.string().trim().min(1).max(2e3),
   contentHash: HashSchema,
-  sizeBytes: z.number().int().nonnegative(),
-  metadata: z.record(z.string(), z.unknown()).default({}),
+  sizeBytes: z3.number().int().nonnegative(),
+  metadata: z3.record(z3.string(), z3.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingExecutionReceiptSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingExecutionReceipt.v2"),
+var TrainingExecutionReceiptSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingExecutionReceipt.v2"),
   id: IdSchema,
   teamId: IdSchema,
   jobId: IdSchema,
@@ -262,14 +344,14 @@ var TrainingExecutionReceiptSchema = z.object({
   recipeHash: HashSchema,
   capabilityHash: HashSchema,
   runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z.number().nonnegative(),
-  durationSeconds: z.number().nonnegative(),
-  cleanupComplete: z.boolean(),
+  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,
   issuedAt: TimestampSchema,
-  signature: z.string().trim().min(1).max(1e4).nullable()
+  signature: z3.string().trim().min(1).max(1e4).nullable()
 }).strict();
 async function trainingExecutionReceiptHash(receipt) {
   return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
@@ -305,18 +387,18 @@ async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
   }
   return receipt;
 }
-var TrainingJobOutputsSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z.array(TrainingJobOutputSchema).max(1e4),
+var TrainingJobOutputsSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z3.array(TrainingJobOutputSchema).max(1e4),
   receipt: TrainingExecutionReceiptSchema.nullable()
 }).strict();
-var TrainingApiErrorSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingApiError.v2"),
-  code: z.string().trim().min(1).max(200),
-  message: z.string().trim().min(1).max(5e3),
-  retryable: z.boolean().default(false),
-  requestId: z.string().trim().min(1).max(500).nullable().default(null),
-  details: z.record(z.string(), z.unknown()).default({})
+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({})
 }).strict();
 var OpenPondTrainingApiError = class extends Error {
   status;
@@ -334,23 +416,23 @@ var OpenPondTrainingApiError = class extends Error {
     this.details = error.details;
   }
 };
-var TrainingCapabilitiesSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingCapabilities.v2"),
+var TrainingCapabilitiesSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingCapabilities.v2"),
   capabilityHash: HashSchema,
-  jobKinds: z.array(TrainingJobKindSchema),
-  methods: z.array(z.string().trim().min(1).max(200)),
-  placements: z.array(
-    z.enum(["local", "remote", "colocated", "provider_native"])
+  jobKinds: z3.array(TrainingJobKindSchema),
+  methods: z3.array(z3.string().trim().min(1).max(200)),
+  placements: z3.array(
+    z3.enum(["local", "remote", "colocated", "provider_native"])
   ),
-  controls: z.object({
-    cancel: z.boolean(),
-    stopAfterGroup: z.boolean(),
-    resumeFromCheckpoint: z.boolean()
+  controls: z3.object({
+    cancel: z3.boolean(),
+    stopAfterGroup: z3.boolean(),
+    resumeFromCheckpoint: z3.boolean()
   }).strict(),
-  limits: z.object({
-    maximumSpendUsd: z.number().nonnegative(),
-    maximumWallSeconds: z.number().int().positive(),
-    maximumArtifactBytes: z.number().int().positive()
+  limits: z3.object({
+    maximumSpendUsd: z3.number().nonnegative(),
+    maximumWallSeconds: z3.number().int().positive(),
+    maximumArtifactBytes: z3.number().int().positive()
   }).strict(),
   checkedAt: TimestampSchema,
   expiresAt: TimestampSchema
@@ -441,12 +523,12 @@ function createTrainingClient(input) {
         parameters.set("modelProjectId", IdSchema.parse(options.modelProjectId));
       }
       if (options.cursor) {
-        parameters.set("cursor", z.string().trim().min(1).max(2e3).parse(options.cursor));
+        parameters.set("cursor", z3.string().trim().min(1).max(2e3).parse(options.cursor));
       }
       if (options.limit !== void 0) {
         parameters.set(
           "limit",
-          String(z.number().int().min(1).max(1e3).parse(options.limit))
+          String(z3.number().int().min(1).max(1e3).parse(options.limit))
         );
       }
       const query = parameters.size > 0 ? `?${parameters.toString()}` : "";
@@ -487,7 +569,7 @@ function createTrainingClient(input) {
       );
     },
     async events(jobId) {
-      return z.array(TrainingJobEventSchema).parse(
+      return z3.array(TrainingJobEventSchema).parse(
         unwrapObject(
           await request(
             `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/events`
@@ -504,7 +586,7 @@ function createTrainingClient(input) {
       );
     },
     async logs(jobId) {
-      return z.array(TrainingJobLogSchema).max(1e5).parse(
+      return z3.array(TrainingJobLogSchema).max(1e5).parse(
         unwrapObject(
           await request(
             `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(jobId))}/logs`
@@ -541,6 +623,11 @@ function trainingApiError(value, status) {
 }
 
 export {
+  deterministicTrainingRewardSource,
+  TRAINING_EVALUATION_SOURCE_PATH,
+  TrainingEvaluationSourceSchema,
+  assertTrainingEvaluationIsolation,
+  trainingEvaluationSourceRef,
   TrainingInputArtifactUploadSchema,
   TrainingInputArtifactSchema,
   trainingInputArtifactUploadHash,
@@ -571,4 +658,4 @@ export {
   TrainingCapabilitiesSchema,
   createTrainingClient
 };
-//# sourceMappingURL=chunk-AVW35YOH.js.map
+//# sourceMappingURL=chunk-OJERFIEJ.js.map