openpond-sdk 0.5.8 → 0.5.10

package/dist/training-bundle.js

@@ -2,12 +2,12 @@ import {
   learningVerifierModule,
   projectLearningBatchGraders,
   resolvePortableTasksetRewardExecution
-} from "./chunk-ARUJ3FJT.js";
+} from "./chunk-7VZB24CH.js";
 import {
   LearningBatchDatasetSourceRefSchema,
   TasksetSchema,
   computeTasksetHash
-} from "./chunk-QFT2MCIC.js";
+} from "./chunk-WSTMQGOY.js";
 import "./chunk-4IDTRFW2.js";
 import "./chunk-S7I45WJQ.js";
 import {
@@ -22,8 +22,10 @@ import {
 } from "./chunk-F5JBFRAH.js";
 import {
   HarnessSourceSelectionSchema,
+  createAgentSnapshot,
+  createHarnessRelease,
   validateHarnessSourcePackage
-} from "./chunk-UKVK7MRJ.js";
+} from "./chunk-5FBPNWT4.js";
 import {
   ImmutableReleaseRefSchema,
   ReleaseHashSchema,
@@ -214,10 +216,10 @@ function materializeLearningBatchTaskset(input) {
   const generatedFiles = [];
   for (const grader of release.graders) {
     if (grader.kind !== "custom_verifier") continue;
-    const asset = input.assets?.find((asset2) => asset2.id === grader.verifierRef.id);
-    if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable verifier source.`);
+    const asset2 = input.assets?.find((asset3) => asset3.id === grader.verifierRef.id);
+    if (!asset2) throw new Error(`Reward ${grader.id} is missing its immutable verifier source.`);
     const module = learningVerifierModule(grader.verifierRef.contentHash);
-    if (!generatedFiles.some((file) => file.path === module)) generatedFiles.push({ path: module, role: "verifier", content: verifyLearningTextAsset(asset, grader.verifierRef) });
+    if (!generatedFiles.some((file) => file.path === module)) generatedFiles.push({ path: module, role: "verifier", content: verifyLearningTextAsset(asset2, grader.verifierRef) });
   }
   const taskset = TasksetSchema.parse({
     schemaVersion: "openpond.taskset.v1",
@@ -371,6 +373,269 @@ function verifyFiles(bundle, files) {
   });
 }
 
+// src/training-recipe-binding.ts
+import { z as z3 } from "zod";
+var AdamwOptimizerConfigSchema = z3.object({
+  name: z3.literal("adamw").default("adamw"),
+  weightDecay: z3.number().nonnegative().max(1).default(0),
+  beta1: z3.number().positive().lt(1).default(0.9),
+  beta2: z3.number().positive().lt(1).default(0.999),
+  epsilon: z3.number().positive().max(0.01).default(1e-8)
+}).strict().default({
+  name: "adamw",
+  weightDecay: 0,
+  beta1: 0.9,
+  beta2: 0.999,
+  epsilon: 1e-8
+});
+function withAuthoritativeRecipeHashes(taskset, recipe) {
+  if (!recipe || typeof recipe !== "object" || Array.isArray(recipe)) {
+    return recipe;
+  }
+  const candidate = recipe;
+  if (candidate.method === "dpo") {
+    const policyModel = record(candidate.policyModel);
+    const referenceModel = record(candidate.referenceModel);
+    const dataset2 = record(candidate.dataset);
+    const invalidationHash = contentHash({
+      tasksetHash: taskset.contentHash,
+      preferenceSignals: taskset.learningSignals.preferences.map((signal) => ({
+        id: signal.id,
+        artifactRef: signal.artifactRef,
+        prompt: signal.prompt,
+        chosen: signal.chosen,
+        rejected: signal.rejected,
+        approved: signal.approved
+      })),
+      policyModel,
+      referenceModel,
+      dataset: dataset2
+    });
+    return {
+      ...candidate,
+      referenceLogprobs: {
+        cacheSchemaVersion: "openpond.dpoReferenceLogprobs.v1",
+        cacheKey: contentHash(["dpo-reference-logprobs", invalidationHash]),
+        invalidationHash
+      }
+    };
+  }
+  if (candidate.method === "ppo") {
+    const policyOptimization = record(candidate.policyOptimization);
+    const policyModel = record(policyOptimization.policyModel);
+    const referenceModel = record(policyOptimization.referenceModel);
+    const optimizer2 = record(policyOptimization.optimizer);
+    const valueModel = record(optimizer2.valueModel);
+    const dataset2 = record(policyOptimization.dataset);
+    const reward2 = record(policyOptimization.reward);
+    const policyHash = contentHash(policyModel);
+    const referenceHash = contentHash(referenceModel);
+    const valueModelHash = contentHash(valueModel);
+    return {
+      ...candidate,
+      policyOptimization: {
+        ...policyOptimization,
+        dataset: {
+          ...dataset2,
+          tasksetId: taskset.id,
+          tasksetHash: taskset.contentHash
+        },
+        reward: {
+          ...reward2,
+          graderHash: contentHash(taskset.graders)
+        }
+      },
+      resume: {
+        ...record(candidate.resume),
+        policyHash,
+        referenceHash,
+        valueModelHash
+      }
+    };
+  }
+  if (candidate.method !== "grpo") return recipe;
+  const reward = candidate.reward && typeof candidate.reward === "object" && !Array.isArray(candidate.reward) ? candidate.reward : {};
+  const metadataToolContractHash = taskset.environment.metadata.toolContractHash;
+  const authoritativeToolContractHash = typeof metadataToolContractHash === "string" && metadataToolContractHash.trim() ? metadataToolContractHash : reward.toolContractHash;
+  const baseModel = record(candidate.baseModel);
+  const dataset = record(candidate.dataset);
+  const rollout = record(candidate.rollout);
+  const optimizer = record(candidate.optimizer);
+  const loss = record(candidate.loss);
+  const resourceLimits = record(candidate.resourceLimits);
+  const maxExamples = positiveInteger(dataset.maxExamples, 1);
+  const groupSize = positiveInteger(rollout.groupSize, 2);
+  const maxOutputTokens = positiveInteger(rollout.maxOutputTokens, 1);
+  const maxPromptTokens = positiveInteger(dataset.maxPromptTokens, 1);
+  const maxSteps = positiveInteger(optimizer.maxSteps, 1);
+  const optimizerIterations = positiveInteger(optimizer.iterations, 2);
+  return {
+    ...candidate,
+    resourceLimits: {
+      ...resourceLimits,
+      maxGpuSeconds: resourceLimits.maxGpuSeconds ?? Math.min(
+        10800,
+        Math.ceil(positiveInteger(resourceLimits.wallTimeMs, 18e4) / 1e3)
+      )
+    },
+    reward: {
+      ...reward,
+      graderHash: contentHash(taskset.graders),
+      toolContractHash: authoritativeToolContractHash
+    },
+    policyOptimization: {
+      schemaVersion: "openpond.policyOptimization.v1",
+      policyModel: baseModel,
+      referenceModel: baseModel,
+      dataset: {
+        tasksetId: taskset.id,
+        tasksetHash: taskset.contentHash,
+        split: "train",
+        selectionStrategy: dataset.selectionStrategy,
+        selectionSeed: rollout.seed,
+        maxExamples
+      },
+      sampler: {
+        temperature: rollout.temperature,
+        topP: rollout.topP,
+        maxOutputTokens,
+        maxTurns: rollout.maxTurns,
+        concurrency: rollout.concurrency
+      },
+      environment: {
+        id: reward.environmentId,
+        version: reward.environmentVersion,
+        toolContractHash: authoritativeToolContractHash
+      },
+      reward: {
+        graderId: reward.graderId,
+        graderHash: contentHash(taskset.graders),
+        learnedPreference: reward.learnedPreference ?? null
+      },
+      kl: {
+        coefficient: loss.klBeta ?? null,
+        referenceConstraint: "fixed_reference"
+      },
+      budgets: {
+        maxRollouts: positiveInteger(resourceLimits.maxRollouts, maxExamples * groupSize),
+        maxEnvironmentExecutions: positiveInteger(resourceLimits.maxRollouts, maxExamples * groupSize),
+        maxInputTokens: maxExamples * groupSize * maxPromptTokens,
+        maxOutputTokens: maxExamples * groupSize * maxOutputTokens,
+        maxOptimizerSteps: maxSteps * optimizerIterations,
+        wallTimeMs: positiveInteger(resourceLimits.wallTimeMs, 18e4),
+        maximumCostUsd: null
+      },
+      checkpointEverySteps: 1,
+      seed: rollout.seed,
+      evaluationSplit: "frozen_eval",
+      optimizer: {
+        method: "grpo",
+        groupSize,
+        normalization: "group_standardized",
+        advantageEpsilon: typeof optimizer.advantageEpsilon === "number" ? optimizer.advantageEpsilon : 1e-8,
+        loss: loss.method ?? "grpo",
+        clipRange: typeof optimizer.clipRange === "number" ? optimizer.clipRange : 0.2,
+        iterations: optimizerIterations,
+        microbatchSize: positiveInteger(optimizer.microbatchSize, 1),
+        gradientAccumulationSteps: positiveInteger(
+          optimizer.gradientAccumulationSteps,
+          1
+        ),
+        adamw: AdamwOptimizerConfigSchema.parse(optimizer.adamw)
+      }
+    }
+  };
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function positiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+// src/training-policy-harness.ts
+function createPolicyHarnessContext(input) {
+  const sourceRelease = input.sourceRelease;
+  const harnessTools = [];
+  const skills = input.skills ?? [];
+  const agents = input.agents ?? [];
+  if ([...skills, ...agents].some((entry) => entry.visibility !== "policy")) {
+    throw new Error("The portable policy Harness requires policy-visible dependencies.");
+  }
+  const dependencyLock = asset({
+    id: "desktop-dependency-lock",
+    path: ".openpond/harness/dependency-lock.json",
+    hashInput: {
+      profileHead: input.profileHead ?? null,
+      sourceRelease,
+      tools: harnessTools,
+      skills: skills.map(({ id, contentHash: assetHash }) => ({ id, contentHash: assetHash })),
+      agents: agents.map(({ id, contentHash: assetHash }) => ({ id, contentHash: assetHash }))
+    },
+    mediaType: "application/json",
+    visibility: "policy"
+  });
+  const agentSnapshot = createAgentSnapshot({
+    schemaVersion: "openpond.agentSnapshot.v2",
+    id: `agent-snapshot-${contentHash([sourceRelease, harnessTools, dependencyLock.contentHash]).slice(0, 24)}`,
+    sourceRelease,
+    instructions: [],
+    skills,
+    agents,
+    toolDeclarations: harnessTools,
+    capabilityRequirements: [],
+    dependencyLock,
+    portability: {
+      portable: true,
+      blockers: [],
+      localOnlyAssetRefs: [],
+      hostPrivateAssetRefs: []
+    },
+    metadata: { sourceReleaseId: sourceRelease?.id ?? null }
+  });
+  const program = asset({
+    id: "desktop-harness-program",
+    path: ".openpond/harness/program.json",
+    hashInput: { program: "openpond.desktop-agent-loop.v1" },
+    mediaType: "application/json",
+    visibility: "policy"
+  });
+  const harnessRelease = createHarnessRelease({
+    schemaVersion: "openpond.harnessRelease.v2",
+    id: `harness-${contentHash([agentSnapshot.contentHash, program.contentHash, harnessTools]).slice(0, 24)}`,
+    agentSnapshot: { id: agentSnapshot.id, contentHash: agentSnapshot.contentHash },
+    program,
+    tools: harnessTools,
+    lifecycle: {
+      create: true,
+      reset: true,
+      step: true,
+      collect: true,
+      destroy: true,
+      resetScope: "attempt"
+    },
+    graderInterface: {
+      visibleEvidence: ["output", "runtime_events", "artifacts"],
+      privilegedEvidence: ["expected_output", "private_verifier"],
+      privateVerifierIsolation: true
+    },
+    files: [...skills, ...agents],
+    metadata: { runtimeProtocol: "openpond.desktop-agent-loop.v1" }
+  });
+  return { agentSnapshot, harnessRelease };
+}
+function asset(input) {
+  const bytes2 = canonicalJson(input.hashInput);
+  return {
+    id: input.id,
+    path: input.path,
+    contentHash: contentHash(input.hashInput),
+    sizeBytes: new TextEncoder().encode(bytes2).byteLength,
+    mediaType: input.mediaType,
+    visibility: input.visibility
+  };
+}
+
 // src/training-bundle.ts
 function buildTasksetTrainingBundle(input) {
   const { taskset, modelProject, harnessRelease, tasksetRelease } = input;
@@ -435,11 +700,11 @@ function buildTasksetTrainingBundle(input) {
     const verifierAssets = input.verifierAssets ?? [];
     const references = compileBoundGraders(rewardExecution.binding, rewardExecution.rewards).flatMap((grader) => grader.kind === "custom_verifier" ? [grader.verifierRef] : []);
     const expected = new Set(references.map((reference) => reference.id));
-    if (new Set(verifierAssets.map((asset) => asset.id)).size !== verifierAssets.length || verifierAssets.some((asset) => !expected.has(asset.id))) throw new Error("Unexpected or duplicate private verifier asset.");
+    if (new Set(verifierAssets.map((asset2) => asset2.id)).size !== verifierAssets.length || verifierAssets.some((asset2) => !expected.has(asset2.id))) throw new Error("Unexpected or duplicate private verifier asset.");
     for (const reference of references) {
-      const asset = verifierAssets.find((asset2) => asset2.id === reference.id);
-      if (!asset || reference.visibility !== "verifier") throw new Error("Training bundle requires its private verifier asset.");
-      verifyLearningTextAsset2(asset, reference);
+      const asset2 = verifierAssets.find((asset3) => asset3.id === reference.id);
+      if (!asset2 || reference.visibility !== "verifier") throw new Error("Training bundle requires its private verifier asset.");
+      verifyLearningTextAsset2(asset2, reference);
     }
     addJsonAsset(assets, "reward-binding.json", { kind: "reward_binding_v1", binding: rewardExecution.binding, rewards: rewardExecution.rewards, assets: verifierAssets });
   } else if (input.verifierAssets?.length) {
@@ -565,25 +830,25 @@ function buildTasksetTrainingBundle(input) {
 function addTasksetAssets(input) {
   const expected = /* @__PURE__ */ new Set();
   for (const task of input.tasks) {
-    for (const asset of task.assets ?? []) {
-      if (expected.has(asset.artifactRef)) {
+    for (const asset2 of task.assets ?? []) {
+      if (expected.has(asset2.artifactRef)) {
         throw new Error(
-          `Training asset path ${asset.artifactRef} is shared by multiple tasks.`
+          `Training asset path ${asset2.artifactRef} is shared by multiple tasks.`
         );
       }
-      expected.add(asset.artifactRef);
-      const value = input.tasksetAssetBytes.get(asset.artifactRef);
+      expected.add(asset2.artifactRef);
+      const value = input.tasksetAssetBytes.get(asset2.artifactRef);
       if (!value) {
         throw new Error(
-          `Resolved Training Bundle is missing Work asset ${asset.artifactRef}.`
+          `Resolved Training Bundle is missing Work asset ${asset2.artifactRef}.`
         );
       }
-      if (value.byteLength !== asset.sizeBytes || sha256(value) !== asset.sha256) {
+      if (value.byteLength !== asset2.sizeBytes || sha256(value) !== asset2.sha256) {
         throw new Error(
-          `Resolved Training Bundle Work asset ${asset.artifactRef} failed immutable verification.`
+          `Resolved Training Bundle Work asset ${asset2.artifactRef} failed immutable verification.`
         );
       }
-      input.assets.set(asset.artifactRef, value);
+      input.assets.set(asset2.artifactRef, value);
     }
   }
   for (const assetPath of input.tasksetAssetBytes.keys()) {
@@ -601,6 +866,7 @@ function bytes(value) {
   return Buffer.from(canonicalJson(value), "utf8");
 }
 export {
+  AdamwOptimizerConfigSchema,
   ComputeTargetBindingSchema,
   HarnessRunManifestContentSchema,
   HarnessRunManifestSchema,
@@ -611,9 +877,11 @@ export {
   ScopedSecretDeclarationSchema,
   TrainingEngineBindingSchema,
   buildTasksetTrainingBundle,
+  createPolicyHarnessContext,
   materializeLearningBatchTaskset,
   prepareManagedTrainingSubmission,
   prepareReviewedLearningBatch,
-  scanAndRedactEvidence
+  scanAndRedactEvidence,
+  withAuthoritativeRecipeHashes
 };
 //# sourceMappingURL=training-bundle.js.map