openpond-sdk 0.12.4 → 0.12.6

package/dist/training-bundle.js

@@ -1,26 +1,28 @@
 import {
   prepareImportedTasksetPackage,
   projectLearningBatchGraders
-} from "./chunk-CMWZZZGW.js";
+} from "./chunk-QDYHSJT5.js";
 import {
   projectPortableTaskRecord,
   resolvePortableTasksetRewardExecution
-} from "./chunk-WQFU635Q.js";
+} from "./chunk-ATVQQCYN.js";
 import {
+  TasksetDraftOutputContractSchema,
   TasksetSchema,
   computeTasksetHash
-} from "./chunk-GAIDBPFY.js";
+} from "./chunk-ONGOAEY6.js";
 import {
   LearningBatchDatasetSourceRefSchema,
   MAX_TASKSET_PACKAGE_BYTES,
   decodeTasksetPackageFile,
   validateTasksetPackage
-} from "./chunk-MO4HAJZG.js";
+} from "./chunk-2XLKMZH5.js";
 import "./chunk-TK3DXH7A.js";
 import {
   TRAINING_EVALUATION_SOURCE_PATH,
   TrainingCapabilitiesSchema,
   TrainingEvaluationSourceSchema,
+  TrainingPhysicalPlacementSchema,
   assertTrainingEvaluationIsolation,
   deterministicTrainingRewardSource,
   parseAndVerifyTrainingInputArtifactUpload,
@@ -28,11 +30,11 @@ import {
   trainingEvaluationSourceRef,
   trainingInputArtifactUploadHash,
   trainingJobSubmissionHash
-} from "./chunk-RRKRA237.js";
+} from "./chunk-Z4XGSEKC.js";
 import {
   TrainingHandoffOriginSchema
-} from "./chunk-ZHQK3MOM.js";
-import "./chunk-WMIKJGXW.js";
+} from "./chunk-LIMTJR3A.js";
+import "./chunk-3VGTVZHL.js";
 import {
   HarnessSourceSelectionSchema,
   createAgentSnapshot,
@@ -41,10 +43,12 @@ import {
   validateHarnessSourcePackage
 } from "./chunk-Q4TKI2MV.js";
 import "./chunk-H3367ISL.js";
-import "./chunk-QRS7Y3EM.js";
-import "./chunk-VN5V2E2S.js";
-import "./chunk-U7XWIOSB.js";
-import "./chunk-HGXVOFCL.js";
+import "./chunk-B2MKB7NB.js";
+import "./chunk-HRZLFJXX.js";
+import "./chunk-5T76GARR.js";
+import {
+  TrainingGpuSelectionSchema
+} from "./chunk-3SIGXGAE.js";
 import "./chunk-CL3IOOVL.js";
 import {
   ImmutableReleaseRefSchema,
@@ -367,6 +371,7 @@ async function prepareManagedTrainingSubmission(raw) {
   const manifest = HarnessRunManifestSchema.parse(input.manifest);
   const bundle = ResolvedTrainingBundleManifestSchema.parse(input.bundleManifest);
   const qualification = input.executionMode === "qualification";
+  const physicalPlacement = input.physicalPlacement ? TrainingPhysicalPlacementSchema.parse(input.physicalPlacement) : void 0;
   const qualificationGroupSize = manifest.qualificationSamples === void 0 ? null : z2.object({ rollout: z2.object({ groupSize: z2.number().int().min(2).max(32) }).passthrough() }).passthrough().parse(recipe).rollout.groupSize;
   if (manifest.qualificationSamples !== bundle.qualificationSamples || manifest.qualificationSamples !== void 0 && (!qualification || manifest.qualificationSamples > qualificationGroupSize)) {
     throw new Error("Qualification samples must be within the pinned rollout group and cannot be used for training.");
@@ -411,6 +416,7 @@ async function prepareManagedTrainingSubmission(raw) {
     schemaVersion: "openpond.managedRlPortableSubmission.v1",
     ...qualification ? { executionMode: "qualification" } : {},
     ...input.origin ? { origin: TrainingHandoffOriginSchema.parse(input.origin) } : {},
+    ...physicalPlacement ? { physicalPlacement } : {},
     sourceRunRef: `openpond:model-run:${manifest.id}`,
     name: `OpenPond Managed \xB7 ${project.id}`.slice(0, 191),
     idempotencyKey: input.idempotencyKey ?? `openpond-managed:${manifestHash}`.slice(0, 191),
@@ -475,6 +481,8 @@ async function prepareManagedTrainingSubmission(raw) {
       ...project.trainingSetup.managedGpuRequirement === "h100_hbm3" ? [{ id: "managed_rl.gpu.h100_hbm3", version: "1", required: true }] : []
     ],
     placementObjective: project.trainingSetup.managedGpuPlacementObjective,
+    ...input.gpuSelection ?? project.trainingSetup.managedGpuSelection ? { gpuSelection: TrainingGpuSelectionSchema.parse(input.gpuSelection ?? project.trainingSetup.managedGpuSelection) } : {},
+    ...physicalPlacement ? { physicalPlacement } : {},
     budget: {
       maximumSpendUsd: approval.maximumSpendUsd,
       maximumWallSeconds: Math.ceil(limits.wallTimeMs / 1e3)
@@ -598,6 +606,8 @@ function withAuthoritativeRecipeHashes(taskset, recipe) {
   const maxPromptTokens = positiveInteger(dataset.maxPromptTokens, 1);
   const maxSteps = positiveInteger(optimizer.maxSteps, 1);
   const optimizerIterations = positiveInteger(optimizer.iterations, 2);
+  const maxRollouts = positiveInteger(resourceLimits.maxRollouts, maxSteps * groupSize);
+  const maxTurns = positiveInteger(rollout.maxTurns, 1);
   return {
     ...candidate,
     resourceLimits: {
@@ -646,10 +656,12 @@ function withAuthoritativeRecipeHashes(taskset, recipe) {
         referenceConstraint: "fixed_reference"
       },
       budgets: {
-        maxRollouts: positiveInteger(resourceLimits.maxRollouts, maxExamples * groupSize),
-        maxEnvironmentExecutions: positiveInteger(resourceLimits.maxRollouts, maxExamples * groupSize),
-        maxInputTokens: maxExamples * groupSize * maxPromptTokens,
-        maxOutputTokens: maxExamples * groupSize * maxOutputTokens,
+        maxRollouts,
+        maxEnvironmentExecutions: maxRollouts,
+        // Tasks can be sampled over multiple groups, and every tool turn can
+        // generate another policy request within the same rollout.
+        maxInputTokens: maxRollouts * maxTurns * maxPromptTokens,
+        maxOutputTokens: maxRollouts * maxTurns * maxOutputTokens,
         maxOptimizerSteps: maxSteps * optimizerIterations,
         wallTimeMs: positiveInteger(resourceLimits.wallTimeMs, 18e4),
         maximumCostUsd: null
@@ -768,6 +780,48 @@ function asset(input) {
 // src/training-qualification-preparation.ts
 import { createRewardBinding, createRewardRelease, compileBoundGraders } from "@openpond/evals/rewards";
 import { LearningTextAssetSchema, sealLearningContent } from "@openpond/evals/learning";
+
+// src/training-verifier-assets.ts
+async function qualificationVerifierAssets(source, entry) {
+  const [{ isBuiltin }, { posix }, { build }] = await Promise.all([
+    import("node:module"),
+    import("node:path"),
+    import("esbuild")
+  ]);
+  const files = new Map(source.files.map((file) => [file.asset.path, file]));
+  const selected = /* @__PURE__ */ new Map();
+  await build({
+    entryPoints: [entry.path],
+    bundle: true,
+    write: false,
+    platform: "node",
+    format: "esm",
+    treeShaking: false,
+    logLevel: "silent",
+    plugins: [{ name: "qualification-private-modules", setup(builder) {
+      builder.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind !== "entry-point" && isBuiltin(args.path)) return { path: args.path, external: true };
+        if (args.kind !== "entry-point" && !args.path.startsWith("./") && !args.path.startsWith("../")) {
+          throw new Error(`Qualification verifier import must be a declared relative module or Node builtin: ${args.path}.`);
+        }
+        const path = args.kind === "entry-point" ? args.path : posix.normalize(posix.join(posix.dirname(args.importer), args.path));
+        const file = files.get(path);
+        if (!file || file.asset.visibility !== "verifier" || !/\.[cm]?js$/.test(path)) {
+          throw new Error(`Qualification verifier dependency requires a declared verifier-visible JavaScript asset: ${path}.`);
+        }
+        return { path, namespace: "qualification-private-modules" };
+      });
+      builder.onLoad({ filter: /.*/, namespace: "qualification-private-modules" }, (args) => {
+        const file = files.get(args.path);
+        selected.set(file.asset.id, file.asset);
+        return { contents: new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file)), loader: "js" };
+      });
+    } }]
+  });
+  return [...selected.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+
+// src/training-qualification-preparation.ts
 async function prepareOrdinaryTasksetQualification(input) {
   const source = validateTasksetPackage(input.package);
   if (source.taskset.tasks.some((task) => task.requiredOutputs?.some((output) => output.submissionMode === "structured_json"))) {
@@ -782,7 +836,7 @@ async function prepareOrdinaryTasksetQualification(input) {
   if (source.taskset.tasks.some((task) => task.privilegedContextRef !== null || task.artifactRefs.some((asset2) => asset2.visibility !== "policy"))) {
     throw new Error("Qualification runtime requires private targets in expectedOutput and policy-only task assets.");
   }
-  const rewards = source.taskset.graders.map((grader) => {
+  const rewards = await Promise.all(source.taskset.graders.map(async (grader) => {
     const { id, version, weight: _weight, hardGate: _gate, rewardEligible: _eligible, privileged: _private, taskIds: _tasks, ...implementation } = grader;
     const revision = Number(version);
     if (!Number.isSafeInteger(revision) || revision < 1 || String(revision) !== version || implementation.kind === "model_judge" || implementation.kind === "human") {
@@ -796,9 +850,9 @@ async function prepareOrdinaryTasksetQualification(input) {
       description: "Exact ordinary package grader for no-update qualification.",
       implementation,
       rawScore: { minimum: 0, maximum: 1 },
-      assets: implementation.kind === "custom_verifier" ? [implementation.verifierRef] : []
+      assets: implementation.kind === "custom_verifier" ? await qualificationVerifierAssets(source, implementation.verifierRef) : []
     });
-  });
+  }));
   const binding = createRewardBinding({
     schemaVersion: "openpond.rewardBinding.v1",
     id: `qualification-${source.contentHash.slice(0, 40)}`,
@@ -964,9 +1018,17 @@ function buildTasksetTrainingBundle(input) {
   } else if (input.verifierAssets?.length) {
     throw new Error("Private verifier assets require a published Reward binding.");
   }
+  const outputContract = taskset.metadata.tasksetOutputContract;
+  if (outputContract && typeof outputContract === "object" && "responsePath" in outputContract) {
+    TasksetDraftOutputContractSchema.parse({ jsonSchema: null, renderer: null, ...outputContract });
+  }
   addJsonAsset(assets, "environment.json", {
     schemaVersion: "openpond.harnessEnvironment.v1",
-    environment: qualification ? { ...taskset.environment, metadata: { ...taskset.environment.metadata, policySystemPrompt: taskset.objective } } : taskset.environment,
+    // Authored instructions are part of every policy run. Qualification already
+    // binds this value; training must not silently fall back to a generic prompt.
+    // The objective owns this field, while selected Harness source remains a
+    // separate immutable input composed by the runtime.
+    environment: { ...taskset.environment, metadata: { ...taskset.environment.metadata, policySystemPrompt: taskset.objective } },
     capabilities: taskset.capabilities,
     policy: taskset.policy,
     outputContract: taskset.metadata.tasksetOutputContract?.mode === "text" ? null : taskset.metadata.tasksetOutputContract ?? null