openpond-sdk 0.2.3 → 0.2.4

package/dist/taskset-packages.js

@@ -1,5 +1,5 @@
 // src/taskset-package-contracts.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 
 // ../harness/dist/common.js
 import { z } from "zod";
@@ -1859,6 +1859,63 @@ import { validateTaskValue } from "@openpond/evals/task-schema";
 // src/model-projects.ts
 import { z as z11 } from "zod";
 import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+
+// src/protocol.ts
+var OpenPondProtocolError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OpenPondProtocolError";
+    this.code = code;
+  }
+};
+function canonicalJson2(value) {
+  return JSON.stringify(normalizeCanonicalJson(value));
+}
+function normalizeCanonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new OpenPondProtocolError(
+        "non_json_value",
+        "Canonical JSON cannot contain a non-finite number."
+      );
+    }
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeCanonicalJson(entry));
+  }
+  if (typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new OpenPondProtocolError(
+        "non_json_value",
+        "Canonical JSON accepts only plain objects."
+      );
+    }
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      const entry = value[key];
+      if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") {
+        throw new OpenPondProtocolError(
+          "non_json_value",
+          `Canonical JSON cannot contain ${typeof entry} at ${key}.`
+        );
+      }
+      result[key] = normalizeCanonicalJson(entry);
+    }
+    return result;
+  }
+  throw new OpenPondProtocolError(
+    "non_json_value",
+    `Canonical JSON cannot contain ${typeof value}.`
+  );
+}
+
+// src/model-projects.ts
 var IdSchema = z11.string().trim().min(1).max(500);
 var HashSchema = z11.string().regex(/^[a-f0-9]{64}$/);
 var TimestampSchema = z11.string().datetime({ offset: true });
@@ -2189,22 +2246,381 @@ function validateModelTasksetPackage(value) {
   return result;
 }
 
+// src/taskset-package-contracts.ts
+import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
+
+// src/taskset-package-learning.ts
+import { z as z16 } from "zod";
+import {
+  TaskBatchSchema,
+  TaskEvidenceSchema,
+  TaskAdmissionDecisionSchema,
+  LearningSourceSchema,
+  LearningTextAssetSchema as LearningTextAssetSchema2,
+  assertLearningContentHash as assertLearningContentHash2,
+  compileTaskBatch,
+  learningRef as learningRef3,
+  sameLearningRef as sameLearningRef2,
+  taskBatchPackageMetadata,
+  verifyLearningTextAsset as verifyLearningTextAsset4
+} from "@openpond/evals/learning";
+
+// src/training.ts
+import { z as z15 } from "zod";
+var IdSchema2 = z15.string().trim().min(1).max(500);
+var HashSchema3 = z15.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema2 = z15.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z15.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z15.string().trim().min(1).max(500),
+  sourceManifest: ModelProjectImmutableRefSchema,
+  payload: z15.unknown(),
+  contentHash: HashSchema3
+}).strict();
+var TrainingInputArtifactSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingInputArtifact.v2"),
+  kind: z15.enum(["portable_training_bundle", "reward_model_dataset"]),
+  sourceManifest: ModelProjectImmutableRefSchema,
+  artifactRef: z15.string().trim().min(1).max(2e3),
+  contentHash: HashSchema3,
+  sizeBytes: z15.number().int().positive(),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingJobKindSchema = z15.enum([
+  "reward_model_train",
+  "policy_optimize"
+]);
+var TrainingJobStateSchema = z15.enum([
+  "queued",
+  "admitting",
+  "provisioning",
+  "running",
+  "stopping",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled"
+]);
+var TrainingCapabilityRequirementSchema = z15.object({
+  id: IdSchema2,
+  version: z15.string().trim().min(1).max(200).nullable().default(null),
+  required: z15.boolean().default(true)
+}).strict();
+var TrainingJobSourceSchema = z15.object({
+  modelProject: z15.object({
+    id: IdSchema2,
+    portableProjectId: IdSchema2,
+    revision: z15.number().int().positive(),
+    contentHash: HashSchema3
+  }).strict(),
+  harnessRunManifest: ModelProjectImmutableRefSchema,
+  harnessRelease: ModelProjectImmutableRefSchema,
+  taskset: ModelProjectVersionedRefSchema,
+  tasksetRelease: ModelProjectImmutableRefSchema,
+  dataset: ModelProjectImmutableRefSchema,
+  evidenceSets: z15.array(ModelProjectImmutableRefSchema).max(1e4)
+}).strict();
+var RewardModelTrainingRequestSchema = z15.object({
+  kind: z15.literal("reward_model_train"),
+  baseModel: ModelProjectBaseModelSchema,
+  preferenceDatasetRelease: ModelProjectImmutableRefSchema,
+  processorRelease: ModelProjectImmutableRefSchema,
+  recipe: z15.object({
+    schemaVersion: z15.literal("openpond.rewardModelRecipe.v1"),
+    method: z15.literal("reward_model"),
+    parameterization: z15.literal("lora_with_scalar_head")
+  }).catchall(z15.unknown())
+}).strict();
+var DeterministicRewardSourceSchema = z15.object({
+  kind: z15.literal("deterministic"),
+  grader: ModelProjectImmutableRefSchema,
+  composer: ModelProjectImmutableRefSchema.nullable().default(null)
+}).strict();
+var LearnedRewardSourceSchema = z15.object({
+  kind: z15.literal("learned_reward"),
+  rewardModelVersion: ModelProjectImmutableRefSchema,
+  qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
+  evaluationReferences: z15.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z15.object({
+    artifactRef: z15.string().trim().min(1).max(2e3),
+    contentHash: HashSchema3,
+    executionReceipt: ModelProjectImmutableRefSchema
+  }).strict(),
+  processorRelease: ModelProjectImmutableRefSchema,
+  rewardComposerRelease: ModelProjectImmutableRefSchema
+}).strict();
+var PolicyOptimizationRequestSchema = z15.object({
+  kind: z15.literal("policy_optimize"),
+  baseModel: ModelProjectBaseModelSchema,
+  recipe: ModelProjectRecipeDocumentSchema,
+  rewardSource: z15.discriminatedUnion("kind", [
+    DeterministicRewardSourceSchema,
+    LearnedRewardSourceSchema
+  ]),
+  resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
+}).strict();
+var TrainingJobRequestSchema = z15.discriminatedUnion("kind", [
+  RewardModelTrainingRequestSchema,
+  PolicyOptimizationRequestSchema
+]);
+var TrainingJobApprovalSchema = z15.object({
+  approvalHash: HashSchema3,
+  approvedAt: TimestampSchema2,
+  exportApproved: z15.boolean(),
+  maximumSpendUsd: z15.number().nonnegative(),
+  retentionDays: z15.number().int().nonnegative().nullable(),
+  region: z15.string().trim().min(1).max(200).nullable().default(null)
+}).strict();
+var TrainingJobSubmissionSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z15.string().trim().min(1).max(500),
+  name: z15.string().trim().min(1).max(200),
+  source: TrainingJobSourceSchema,
+  job: TrainingJobRequestSchema,
+  requestedCapabilities: z15.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z15.enum(["fast", "balanced", "economical"]),
+  budget: z15.object({
+    maximumSpendUsd: z15.number().nonnegative(),
+    maximumWallSeconds: z15.number().int().positive()
+  }).strict(),
+  approval: TrainingJobApprovalSchema,
+  contentHash: HashSchema3
+}).strict().superRefine((submission, context) => {
+  if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
+    context.addIssue({
+      code: "custom",
+      path: ["approval", "maximumSpendUsd"],
+      message: "Approved spend must equal the immutable Job budget."
+    });
+  }
+});
+var TrainingJobSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJob.v2"),
+  id: IdSchema2,
+  teamId: IdSchema2,
+  kind: TrainingJobKindSchema,
+  modelProjectId: IdSchema2,
+  portableProjectId: IdSchema2,
+  sourceProjectRevision: z15.number().int().positive(),
+  submissionHash: HashSchema3,
+  state: TrainingJobStateSchema,
+  phase: z15.string().trim().min(1).max(200),
+  version: z15.number().int().nonnegative(),
+  progress: z15.number().min(0).max(1),
+  rolloutProgress: z15.object({
+    groupsCompleted: z15.number().int().nonnegative(),
+    groupsTarget: z15.number().int().nonnegative(),
+    optimizerUpdatesApplied: z15.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z15.number().int().nonnegative()
+  }).strict(),
+  accruedSpendUsd: z15.number().nonnegative(),
+  terminalReason: z15.string().trim().min(1).max(5e3).nullable(),
+  createdAt: TimestampSchema2,
+  updatedAt: TimestampSchema2,
+  completedAt: TimestampSchema2.nullable()
+}).strict();
+var TrainingJobPageSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobPage.v2"),
+  jobs: z15.array(TrainingJobSchema).max(1e3),
+  nextCursor: z15.string().trim().min(1).max(2e3).nullable()
+}).strict();
+var TrainingJobEventSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobEvent.v2"),
+  id: IdSchema2,
+  jobId: IdSchema2,
+  sequence: z15.number().int().nonnegative(),
+  type: IdSchema2,
+  phase: z15.string().trim().min(1).max(200),
+  message: z15.string().trim().min(1).max(5e3).nullable(),
+  data: z15.record(z15.string(), z15.unknown()).default({}),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingJobLogSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobLog.v2"),
+  jobId: IdSchema2,
+  sequence: z15.number().int().nonnegative(),
+  level: z15.enum(["debug", "info", "warning", "error"]),
+  message: z15.string().max(2e4),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingJobControlRequestSchema = z15.object({ expectedVersion: z15.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobOutput.v2"),
+  id: IdSchema2,
+  jobId: IdSchema2,
+  kind: z15.enum([
+    "checkpoint",
+    "adapter",
+    "scorer",
+    "metrics",
+    "evaluation",
+    "trace",
+    "receipt"
+  ]),
+  artifactRef: z15.string().trim().min(1).max(2e3),
+  contentHash: HashSchema3,
+  sizeBytes: z15.number().int().nonnegative(),
+  metadata: z15.record(z15.string(), z15.unknown()).default({}),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingExecutionReceiptSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingExecutionReceipt.v2"),
+  id: IdSchema2,
+  teamId: IdSchema2,
+  jobId: IdSchema2,
+  submissionHash: HashSchema3,
+  manifestHash: HashSchema3,
+  recipeHash: HashSchema3,
+  capabilityHash: HashSchema3,
+  runtimeRelease: ModelProjectImmutableRefSchema,
+  inputs: z15.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z15.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z15.number().nonnegative(),
+  durationSeconds: z15.number().nonnegative(),
+  cleanupComplete: z15.boolean(),
+  issuer: IdSchema2,
+  issuedAt: TimestampSchema2,
+  signature: z15.string().trim().min(1).max(1e4).nullable()
+}).strict();
+var TrainingJobOutputsSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z15.array(TrainingJobOutputSchema).max(1e4),
+  receipt: TrainingExecutionReceiptSchema.nullable()
+}).strict();
+var TrainingApiErrorSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingApiError.v2"),
+  code: z15.string().trim().min(1).max(200),
+  message: z15.string().trim().min(1).max(5e3),
+  retryable: z15.boolean().default(false),
+  requestId: z15.string().trim().min(1).max(500).nullable().default(null),
+  details: z15.record(z15.string(), z15.unknown()).default({})
+}).strict();
+var TrainingCapabilitiesSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingCapabilities.v2"),
+  capabilityHash: HashSchema3,
+  jobKinds: z15.array(TrainingJobKindSchema),
+  methods: z15.array(z15.string().trim().min(1).max(200)),
+  placements: z15.array(
+    z15.enum(["local", "remote", "colocated", "provider_native"])
+  ),
+  controls: z15.object({
+    cancel: z15.boolean(),
+    stopAfterGroup: z15.boolean(),
+    resumeFromCheckpoint: z15.boolean()
+  }).strict(),
+  limits: z15.object({
+    maximumSpendUsd: z15.number().nonnegative(),
+    maximumWallSeconds: z15.number().int().positive(),
+    maximumArtifactBytes: z15.number().int().positive()
+  }).strict(),
+  checkedAt: TimestampSchema2,
+  expiresAt: TimestampSchema2
+}).strict();
+
+// src/taskset-package-learning.ts
+var TasksetPackageLearningResourcesSchema = z16.object({
+  batch: TaskBatchSchema,
+  evidence: z16.array(TaskEvidenceSchema).min(1).max(1e4),
+  decisions: z16.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
+  sources: z16.array(LearningSourceSchema).min(1).max(1e4),
+  assets: z16.array(LearningTextAssetSchema2).max(1e3)
+}).strict();
+function learningPackageContextFiles(resources) {
+  return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
+    const text = canonicalJson2(evidence.submission.evaluatorContext);
+    const bytes = new TextEncoder().encode(text);
+    return {
+      asset: {
+        id: `task-evidence:${evidence.contentHash}`,
+        path: `learning/context/${evidence.contentHash}.json`,
+        contentHash: sha256(bytes),
+        sizeBytes: bytes.byteLength,
+        mediaType: "application/json",
+        visibility: "host_private"
+      },
+      base64: btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""))
+    };
+  });
+}
+function validateTasksetLearningResources(taskset, input) {
+  const resources = TasksetPackageLearningResourcesSchema.parse(input);
+  const metadata = taskBatchPackageMetadata(taskset);
+  if (!sameLearningRef2(learningRef3(resources.batch), metadata.batch)) throw new Error("Taskset learning batch differs from its admission metadata.");
+  for (const collection of [resources.evidence, resources.decisions, resources.sources, resources.assets]) {
+    const identities = /* @__PURE__ */ new Set();
+    for (const resource of collection) {
+      assertLearningContentHash2(resource);
+      const key = `${resource.id}:${resource.revision}`;
+      if (identities.has(key)) throw new Error("Taskset learning resource identities must be unique.");
+      identities.add(key);
+    }
+  }
+  if (resources.evidence.length !== resources.batch.examples.length || resources.decisions.length !== resources.batch.examples.length) throw new Error("Taskset learning snapshots must match the admitted batch inventory.");
+  for (const evidence of resources.evidence) {
+    const source = resources.sources.find((source2) => sameLearningRef2(learningRef3(source2), evidence.source));
+    if (!source || !sameLearningRef2(source.taskDefinition, learningRef3(metadata.definition))) throw new Error("Taskset evidence source differs from its task definition.");
+  }
+  if (resources.sources.some((source) => !resources.evidence.some((evidence) => sameLearningRef2(evidence.source, learningRef3(source))))) throw new Error("Taskset package includes an unrelated learning source.");
+  const rewardAssets = metadata.rewards.flatMap((reward) => [
+    ...reward.assets,
+    ...reward.implementation.kind === "custom_verifier" ? [reward.implementation.verifierRef] : reward.implementation.kind === "model_judge" || reward.implementation.kind === "human" ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]);
+  for (const ref of rewardAssets) {
+    const asset = resources.assets.find((asset2) => asset2.id === ref.id);
+    if (!asset) throw new Error("Taskset learning Reward asset is missing.");
+    verifyLearningTextAsset4(asset, ref);
+  }
+  if (resources.assets.some((asset) => !rewardAssets.some((ref) => ref.id === asset.id))) throw new Error("Taskset package includes an unrelated learning asset.");
+  const compiled = compileTaskBatch({
+    batch: resources.batch,
+    definition: metadata.definition,
+    binding: metadata.binding,
+    rewards: metadata.rewards,
+    evidence: resources.evidence,
+    decisions: resources.decisions
+  });
+  const compiledMetadata = taskBatchPackageMetadata(compiled);
+  if (contentHash(compiledMetadata) !== contentHash(metadata)) throw new Error("Taskset admission metadata differs from its reviewed snapshots.");
+  const execution = (release) => ({ policy: release.policy, environment: release.environment, tools: release.tools });
+  if (contentHash(execution(compiled)) !== contentHash(execution(taskset))) throw new Error("Taskset execution differs from its reviewed task definition.");
+  const taskContent = (task) => ({
+    id: task.id,
+    clusterKey: task.clusterKey,
+    split: task.split,
+    input: task.input,
+    expectedOutput: task.expectedOutput,
+    policyVisibleContext: task.policyVisibleContext,
+    privilegedContextRef: task.privilegedContextRef,
+    artifactRefs: task.artifactRefs,
+    requiredOutputs: task.requiredOutputs ?? [],
+    tags: task.tags
+  });
+  if (contentHash(compiled.tasks.map(taskContent)) !== contentHash(taskset.tasks.map(taskContent))) throw new Error("Taskset rows differ from their reviewed evidence.");
+  return resources;
+}
+
 // src/taskset-package-contracts.ts
 var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z15.object({
+var TasksetPackageFileSchema = z17.object({
   asset: ImmutableAssetRefSchema,
-  base64: z15.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
+  base64: z17.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
 }).strict();
 var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z15.object({
-  schemaVersion: z15.literal("openpond.tasksetPackage.v1"),
+var TasksetPackageContentSchema = z17.object({
+  schemaVersion: z17.literal("openpond.tasksetPackage.v1"),
   taskset: TasksetReleaseSchema2,
   environment: EnvironmentReleaseSchema3,
   verifierSet: VerifierSetReleaseSchema3,
-  files: z15.array(TasksetPackageFileSchema).max(1e4),
-  modelResources: BoundModelResourcesSchema.optional()
+  files: z17.array(TasksetPackageFileSchema).max(1e4),
+  modelResources: BoundModelResourcesSchema.optional(),
+  learningResources: TasksetPackageLearningResourcesSchema.optional()
 }).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z15.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z17.string().regex(/^[a-f0-9]{64}$/) }).strict();
+function tasksetPackageRewardBinding(value) {
+  return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
+}
 function decodeTasksetPackageFile(value) {
   const file = TasksetPackageFileSchema.parse(value);
   const raw = atob(file.base64);
@@ -2250,11 +2666,18 @@ function validateTasksetPackage(value) {
   }
   for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
     if (declarations === void 0) continue;
-    for (const resource of z15.array(z15.object({ path: z15.string().min(1) }).passthrough()).parse(declarations)) {
+    for (const resource of z17.array(z17.object({ path: z17.string().min(1) }).passthrough()).parse(declarations)) {
       if (!result.files.some((file) => file.asset.path === resource.path)) throw new Error(`Taskset environment resource is missing: ${resource.path}.`);
     }
   }
-  if (result.modelResources) {
+  if (result.learningResources) {
+    if (result.modelResources) throw new Error("Taskset package cannot declare competing authoring graphs.");
+    const learning = validateTasksetLearningResources(taskset, result.learningResources);
+    for (const expected of learningPackageContextFiles(learning)) {
+      if (!same2(files.get(expected.asset.id), expected)) throw new Error("Taskset private context differs from its reviewed evidence.");
+    }
+    for (const asset of learning.assets) requireAsset(asset.asset);
+  } else if (result.modelResources) {
     const model = validateModelTasksetPackage({ ...result.modelResources, taskset, executionResources: { environment, verifierSet } });
     for (const asset of model.assets) requireAsset(asset.asset);
   } else if (["starter", "rewardBinding", "rewardExecution", "modelTasksetDerivation", "learning"].some((key) => taskset.metadata[key] !== void 0)) {
@@ -2272,45 +2695,45 @@ function same2(left, right) {
 }
 
 // src/taskset-package-client.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // src/taskset-catalog.ts
-import { z as z16 } from "zod";
-var IdSchema2 = z16.string().trim().min(1).max(500);
-var HashSchema3 = z16.string().regex(/^[a-f0-9]{64}$/);
-var TasksetCatalogReleaseRefSchema = z16.object({ id: IdSchema2, revision: z16.number().int().positive(), contentHash: HashSchema3 }).strict();
-var HostedTasksetSummarySchema = z16.object({
-  schemaVersion: z16.literal("openpond.hostedTasksetSummary.v1"),
-  id: IdSchema2,
-  teamId: IdSchema2,
+import { z as z18 } from "zod";
+var IdSchema3 = z18.string().trim().min(1).max(500);
+var HashSchema4 = z18.string().regex(/^[a-f0-9]{64}$/);
+var TasksetCatalogReleaseRefSchema = z18.object({ id: IdSchema3, revision: z18.number().int().positive(), contentHash: HashSchema4 }).strict();
+var HostedTasksetSummarySchema = z18.object({
+  schemaVersion: z18.literal("openpond.hostedTasksetSummary.v1"),
+  id: IdSchema3,
+  teamId: IdSchema3,
   release: TasksetCatalogReleaseRefSchema,
-  name: z16.string().min(1).max(500),
-  description: z16.string().max(2e4),
-  taskCount: z16.number().int().nonnegative(),
-  buildIntent: z16.string().min(1).max(100),
-  methodHint: z16.string().min(1).max(100).nullable(),
-  packageBytes: z16.number().int().nonnegative().nullable(),
-  storedBytes: z16.number().int().nonnegative().nullable(),
-  createdAt: z16.string().datetime({ offset: true })
-}).strict();
-var TasksetCatalogQuerySchema = z16.object({
-  afterId: IdSchema2.optional(),
-  limit: z16.number().int().min(1).max(100).default(30),
-  modelProjectId: IdSchema2.optional()
-}).strict();
-var TasksetCatalogPageSchema = z16.object({
-  items: z16.array(HostedTasksetSummarySchema).max(100),
-  nextCursor: IdSchema2.nullable()
-}).strict();
-var TasksetCatalogErrorSchema = z16.object({
-  code: z16.string().min(1),
-  message: z16.string().min(1)
+  name: z18.string().min(1).max(500),
+  description: z18.string().max(2e4),
+  taskCount: z18.number().int().nonnegative(),
+  buildIntent: z18.string().min(1).max(100),
+  methodHint: z18.string().min(1).max(100).nullable(),
+  packageBytes: z18.number().int().nonnegative().nullable(),
+  storedBytes: z18.number().int().nonnegative().nullable(),
+  createdAt: z18.string().datetime({ offset: true })
+}).strict();
+var TasksetCatalogQuerySchema = z18.object({
+  afterId: IdSchema3.optional(),
+  limit: z18.number().int().min(1).max(100).default(30),
+  modelProjectId: IdSchema3.optional()
+}).strict();
+var TasksetCatalogPageSchema = z18.object({
+  items: z18.array(HostedTasksetSummarySchema).max(100),
+  nextCursor: IdSchema3.nullable()
+}).strict();
+var TasksetCatalogErrorSchema = z18.object({
+  code: z18.string().min(1),
+  message: z18.string().min(1)
 }).strict();
 
 // src/taskset-package-client.ts
-import { learningRef as learningRef3 } from "@openpond/evals/learning";
-var IdSchema3 = z17.string().trim().min(1).max(500);
-var HashSchema4 = z17.string().regex(/^[a-f0-9]{64}$/);
+import { learningRef as learningRef4 } from "@openpond/evals/learning";
+var IdSchema4 = z19.string().trim().min(1).max(500);
+var HashSchema5 = z19.string().regex(/^[a-f0-9]{64}$/);
 var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
   portableProjectId: true,
   name: true,
@@ -2320,35 +2743,35 @@ var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
   sourceRevision: true,
   sourceUpdatedAt: true
 }).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true, recipe: true }) }).strict();
-var TasksetPackagePublicationSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackagePublication.v1"),
-  operationId: IdSchema3,
-  modelProjectId: IdSchema3,
-  expectedProjectEtag: HashSchema4.nullable(),
-  name: z17.string().trim().min(1).max(200),
-  description: z17.string().max(5e3),
-  buildIntent: z17.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
-  methodHint: z17.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
+var TasksetPackagePublicationSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackagePublication.v1"),
+  operationId: IdSchema4,
+  modelProjectId: IdSchema4,
+  expectedProjectEtag: HashSchema5.nullable(),
+  name: z19.string().trim().min(1).max(200),
+  description: z19.string().max(5e3),
+  buildIntent: z19.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
+  methodHint: z19.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
   package: TasksetPackageSchema,
   modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),
-  selection: z17.enum(["select", "attach"]).optional()
+  selection: z19.enum(["select", "attach"]).optional()
 }).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace Model configuration.");
-var TasksetPackageReceiptSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackageReceipt.v1"),
-  teamId: IdSchema3,
-  modelProjectId: IdSchema3,
-  operationId: IdSchema3,
+var TasksetPackageReceiptSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackageReceipt.v1"),
+  teamId: IdSchema4,
+  modelProjectId: IdSchema4,
+  operationId: IdSchema4,
   taskset: TasksetCatalogReleaseRefSchema,
-  packageHash: HashSchema4,
-  hostedTasksetId: IdSchema3,
-  projectEtag: HashSchema4,
+  packageHash: HashSchema5,
+  hostedTasksetId: IdSchema4,
+  projectEtag: HashSchema5,
   project: HostedModelProjectSummarySchema.optional(),
-  selection: z17.enum(["select", "attach"]).optional()
+  selection: z19.enum(["select", "attach"]).optional()
 }).strict();
-var TasksetPackageReadbackSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackageReadback.v1"),
-  teamId: IdSchema3,
-  modelProjectId: IdSchema3,
+var TasksetPackageReadbackSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackageReadback.v1"),
+  teamId: IdSchema4,
+  modelProjectId: IdSchema4,
   package: TasksetPackageSchema
 }).strict();
 var OpenPondTasksetPackageError = class extends Error {
@@ -2381,10 +2804,11 @@ var OpenPondTasksetPackageClient = class {
     if (request.modelConfiguration) {
       const expected = request.modelConfiguration;
       const project = receipt.project;
+      const binding = tasksetPackageRewardBinding(request.package);
       const setup = HostedModelProjectTrainingSetupSchema.parse({
         ...expected.trainingSetup,
-        tasksetRef: learningRef3(release),
-        rewardBindingRef: request.package.modelResources ? learningRef3(request.package.modelResources.rewardBinding) : null,
+        tasksetRef: learningRef4(release),
+        rewardBindingRef: binding ? learningRef4(binding) : null,
         tasksetRelease: null,
         recipe: null
       });
@@ -2395,9 +2819,9 @@ var OpenPondTasksetPackageClient = class {
     return receipt;
   }
   async get(modelProjectId, reference, options = {}) {
-    const project = IdSchema3.parse(modelProjectId);
+    const project = IdSchema4.parse(modelProjectId);
     const ref = TasksetCatalogReleaseRefSchema.parse(reference);
-    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema4.parse(options.expectedPackageHash);
+    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema5.parse(options.expectedPackageHash);
     const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, "GET", void 0, options.signal));
     const taskset = response.package.taskset;
     if (response.teamId !== this.#options.teamId || response.modelProjectId !== project || taskset.id !== ref.id || taskset.revision !== ref.revision || taskset.contentHash !== ref.contentHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the requested release and owner.");
@@ -2434,7 +2858,7 @@ var OpenPondTasksetPackageClient = class {
     }
     const payload = JSON.parse(text);
     if (!response.ok) {
-      const error = z17.object({ code: z17.string(), message: z17.string() }).safeParse(payload);
+      const error = z19.object({ code: z19.string(), message: z19.string() }).safeParse(payload);
       throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : "package_request_failed", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);
     }
     return payload;
@@ -2446,6 +2870,7 @@ export {
   OpenPondTasksetPackageError,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
+  TasksetPackageLearningResourcesSchema,
   TasksetPackageModelConfigurationSchema,
   TasksetPackagePublicationSchema,
   TasksetPackageReadbackSchema,
@@ -2453,6 +2878,9 @@ export {
   TasksetPackageSchema,
   createTasksetPackage,
   decodeTasksetPackageFile,
+  learningPackageContextFiles,
+  tasksetPackageRewardBinding,
+  validateTasksetLearningResources,
   validateTasksetPackage
 };
 //# sourceMappingURL=taskset-packages.js.map