openpond-sdk 0.12.9 → 0.12.11

package/dist/{chunk-EYMZQML2.js → chunk-GJRXJL6G.js}

@@ -1,7 +1,13 @@
+import {
+  createTrainingHardwareClient
+} from "./chunk-EZME7DV4.js";
+import {
+  createTrainingRequest
+} from "./chunk-GX6KMHW2.js";
 import {
   TrainingHandoffOriginSchema,
   createPostTrainingClient
-} from "./chunk-MRUDFIB6.js";
+} from "./chunk-7BYLH47N.js";
 import {
   validateHarnessPolicySourcePackage,
   validateHarnessSourcePackage
@@ -11,51 +17,131 @@ import {
   ModelProjectImmutableRefSchema,
   ModelProjectRecipeDocumentSchema,
   ModelProjectVersionedRefSchema,
-  OPENPOND_TRAINING_MEDIA_TYPE,
+  TrainingEstimateReviewSchema,
+  TrainingGpuCatalogSchema,
+  TrainingGpuSelectionSchema
+} from "./chunk-UOV2LEXS.js";
+import {
   OpenPondProtocolError,
   TRAINING_API_RESPONSE_MAX_BYTES,
   TRAINING_INPUT_ARTIFACT_MAX_BYTES,
   TRAINING_JOB_SUBMISSION_MAX_BYTES,
-  TrainingEstimateReviewSchema,
-  TrainingGpuCatalogSchema,
-  TrainingGpuSelectionSchema,
   assertCanonicalPayloadSize,
-  canonicalSha256,
-  readBoundedJsonResponse
-} from "./chunk-YSEYPMQ3.js";
+  canonicalSha256
+} from "./chunk-B3ZHJ2KK.js";
 import {
   ImmutableReleaseRefSchema
 } from "./chunk-H3JZ3P5T.js";
 
-// src/training-acceptance.ts
+// src/training-supervised.ts
 import { z } from "zod";
-import { assertAcceptanceGroupSnapshot, AcceptanceGroupSnapshotSchema } from "@openpond/evals/learning";
 var Id = z.string().trim().min(1).max(240);
-var TrainingAcceptanceGroupReferenceSchema = ModelProjectImmutableRefSchema.extend({ revision: z.number().int().positive() }).strict();
+var Hash = z.string().trim().min(8).max(256);
+var SftRecipeSchema = z.object({
+  schemaVersion: z.literal("openpond.sftRecipe.v1"),
+  method: z.literal("sft"),
+  parameterization: z.literal("lora"),
+  baseModel: z.object({
+    id: Id,
+    revision: z.string().trim().min(1).max(256),
+    tokenizerRevision: z.string().trim().min(1).max(256),
+    chatTemplateHash: Hash
+  }),
+  dataset: z.object({
+    trainSplit: z.literal("train"),
+    validationSplit: z.enum(["validation", "frozen_eval"]),
+    completionOnly: z.boolean(),
+    maxSequenceLength: z.number().int().positive().max(32768),
+    maxExamples: z.number().int().positive().max(1e5).default(1e3),
+    selectionStrategy: z.literal("stable_hash_top_n").default("stable_hash_top_n"),
+    selectionSeed: z.number().int().default(17)
+  }),
+  lora: z.object({
+    rank: z.number().int().positive().max(256),
+    alpha: z.number().positive().max(1024),
+    dropout: z.number().min(0).max(1),
+    targetModules: z.array(Id).min(1).max(100)
+  }),
+  optimizer: z.object({
+    learningRate: z.number().positive(),
+    epochs: z.number().positive().max(100),
+    maxSteps: z.number().int().positive().max(1e6),
+    batchSize: z.number().int().positive().max(1e4),
+    gradientAccumulationSteps: z.number().int().positive().max(1e4),
+    seed: z.number().int()
+  }),
+  resourceLimits: z.object({
+    cpuThreads: z.number().int().positive().max(256),
+    memoryBytes: z.number().int().positive(),
+    wallTimeMs: z.number().int().positive()
+  })
+});
+var ManagedSftRecipeSchema = SftRecipeSchema.safeExtend({
+  dataset: SftRecipeSchema.shape.dataset.safeExtend({
+    completionOnly: z.literal(true),
+    maxSequenceLength: z.number().int().min(2).max(8192),
+    maxExamples: z.number().int().min(1).max(1e3).default(1e3)
+  }),
+  lora: SftRecipeSchema.shape.lora.safeExtend({
+    rank: z.number().int().min(1).max(64),
+    dropout: z.number().min(0).lt(1),
+    targetModules: z.array(z.enum(["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"])).min(1).max(7)
+  }),
+  optimizer: SftRecipeSchema.shape.optimizer.safeExtend({
+    learningRate: z.number().positive().max(1e-3),
+    epochs: z.number().positive().max(10),
+    maxSteps: z.number().int().min(1).max(128),
+    batchSize: z.number().int().min(1).max(32),
+    gradientAccumulationSteps: z.number().int().min(1).max(32),
+    seed: z.number().int().min(-(2 ** 31)).max(2 ** 31 - 1)
+  }),
+  resourceLimits: SftRecipeSchema.shape.resourceLimits.safeExtend({
+    wallTimeMs: z.number().int().min(1e3).max(216e5)
+  })
+}).superRefine((recipe, context) => {
+  if (recipe.optimizer.batchSize * recipe.optimizer.gradientAccumulationSteps > 32)
+    context.addIssue({
+      code: "custom",
+      path: ["optimizer"],
+      message: "Managed SFT supports at most 32 accumulated examples."
+    });
+  if (new Set(recipe.lora.targetModules).size !== recipe.lora.targetModules.length)
+    context.addIssue({
+      code: "custom",
+      path: ["lora", "targetModules"],
+      message: "Adapter target modules must be unique."
+    });
+});
+
+// src/training-acceptance.ts
+import { z as z2 } from "zod";
+import { assertAcceptanceGroupSnapshot, AcceptanceGroupSnapshotSchema } from "@openpond/evals/learning";
+var Id2 = z2.string().trim().min(1).max(240);
+var TrainingAcceptanceGroupReferenceSchema = ModelProjectImmutableRefSchema.extend({ revision: z2.number().int().positive() }).strict();
 var TrainingAcceptanceGroupSummarySchema = TrainingAcceptanceGroupReferenceSchema.extend({
-  teamId: Id,
-  jobId: Id,
+  teamId: Id2,
+  jobId: Id2,
   plan: ModelProjectImmutableRefSchema,
   baseline: ModelProjectImmutableRefSchema,
   candidate: ModelProjectImmutableRefSchema,
   state: AcceptanceGroupSnapshotSchema.shape.state,
-  updatedAt: z.string().datetime()
+  updatedAt: z2.string().datetime()
 }).strict();
-var TrainingAcceptanceGroupPageSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingAcceptanceGroupPage.v1"),
-  teamId: Id,
-  jobId: Id,
-  groups: z.array(TrainingAcceptanceGroupSummarySchema).max(100),
-  nextCursor: Id.nullable()
+var TrainingAcceptanceGroupPageSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingAcceptanceGroupPage.v1"),
+  teamId: Id2,
+  jobId: Id2,
+  groups: z2.array(TrainingAcceptanceGroupSummarySchema).max(100),
+  nextCursor: Id2.nullable()
 }).strict();
-var TrainingAcceptanceGroupQuerySchema = z.object({
-  cursor: Id.optional(),
-  limit: z.number().int().min(1).max(100).default(25)
+var TrainingAcceptanceGroupQuerySchema = z2.object({
+  cursor: Id2.optional(),
+  limit: z2.number().int().min(1).max(100).default(25)
 }).strict();
 function createTrainingAcceptanceClient(request) {
   const route = (target) => {
-    Id.parse(target.teamId);
-    return `/v1/training/jobs/${encodeURIComponent(Id.parse(target.jobId))}/acceptance-groups`;
+    Id2.parse(target.teamId);
+    return `/v1/training/jobs/${encodeURIComponent(Id2.parse(target.jobId))}/acceptance-groups`;
   };
   return {
     async acceptanceGroups(target, input = {}) {
@@ -71,7 +157,7 @@ function createTrainingAcceptanceClient(request) {
       const reference = expected ? TrainingAcceptanceGroupReferenceSchema.parse({ id: expected.id, revision: expected.revision, contentHash: expected.contentHash }) : null;
       if (reference && reference.id !== groupId) throw new OpenPondProtocolError("acceptance_group_identity_mismatch", "The retained group reference differs from the requested group.");
       const suffix = reference ? `?revision=${reference.revision}` : "";
-      const snapshot = assertAcceptanceGroupSnapshot(await request(`${route(target)}/${encodeURIComponent(Id.parse(groupId))}${suffix}`));
+      const snapshot = assertAcceptanceGroupSnapshot(await request(`${route(target)}/${encodeURIComponent(Id2.parse(groupId))}${suffix}`));
       if (snapshot.manifest.teamId !== target.teamId || snapshot.manifest.trainingJob.id !== target.jobId || snapshot.manifest.id !== groupId || reference && (snapshot.revision !== reference.revision || snapshot.contentHash !== reference.contentHash))
         throw new OpenPondProtocolError("acceptance_group_identity_mismatch", "Acceptance evidence does not match the requested workspace, job or retained revision.");
       return snapshot;
@@ -80,30 +166,30 @@ function createTrainingAcceptanceClient(request) {
 }
 
 // src/training.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/training-recovery.ts
-import { z as z2 } from "zod";
-var id = z2.string().trim().min(1).max(191);
-var hash = z2.string().regex(/^[a-f0-9]{64}$/);
-var ApprovalBodySchema = z2.object({
-  schemaVersion: z2.literal("openpond.checkpointRecoveryResourceApproval.v1"),
+import { z as z3 } from "zod";
+var id = z3.string().trim().min(1).max(191);
+var hash = z3.string().regex(/^[a-f0-9]{64}$/);
+var ApprovalBodySchema = z3.object({
+  schemaVersion: z3.literal("openpond.checkpointRecoveryResourceApproval.v1"),
   ownerUserId: id,
   teamId: id,
   sourceJobId: id,
-  sourceJobVersion: z2.number().int().positive(),
+  sourceJobVersion: z3.number().int().positive(),
   sourceInputManifestSha256: hash,
   checkpointId: id,
   adapterSha256: hash,
   resumeSha256: hash,
-  idempotencyKey: z2.string().trim().min(16).max(191),
-  approvedAt: z2.iso.datetime({ offset: true }),
-  maximumSpendUsd: z2.number().positive().finite().max(30).refine(
+  idempotencyKey: z3.string().trim().min(16).max(191),
+  approvedAt: z3.iso.datetime({ offset: true }),
+  maximumSpendUsd: z3.number().positive().finite().max(30).refine(
     (value) => Number(value.toFixed(6)) === value,
     "Recovery spend must use whole microdollars"
   ),
-  maximumGpuSeconds: z2.number().int().positive().max(21600),
-  maximumWallSeconds: z2.number().int().positive().max(21600)
+  maximumGpuSeconds: z3.number().int().positive().max(21600),
+  maximumWallSeconds: z3.number().int().positive().max(21600)
 }).strict();
 var TrainingCheckpointRecoveryResourceApprovalSchema = ApprovalBodySchema.extend({
   approvalHash: hash
@@ -122,15 +208,15 @@ async function createTrainingCheckpointRecoveryResourceApproval(input) {
     approvalHash: await canonicalSha256(body)
   });
 }
-var TrainingCheckpointRecoveryRequestSchema = z2.object({
+var TrainingCheckpointRecoveryRequestSchema = z3.object({
   resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
-  mode: z2.literal("evaluation_only").optional(),
-  evaluationGpuType: z2.enum(["NVIDIA A100 80GB PCIe", "NVIDIA A100-SXM4-80GB", "NVIDIA H100 80GB HBM3"]).optional(),
-  expectedVersion: z2.number().int().positive(),
+  mode: z3.literal("evaluation_only").optional(),
+  evaluationGpuType: z3.enum(["NVIDIA A100 80GB PCIe", "NVIDIA A100-SXM4-80GB", "NVIDIA H100 80GB HBM3"]).optional(),
+  expectedVersion: z3.number().int().positive(),
   checkpointId: id,
-  idempotencyKey: z2.string().trim().min(16).max(191),
-  maximumSpendUsd: z2.number().positive().finite(),
-  maximumWallSeconds: z2.number().int().positive().max(21600)
+  idempotencyKey: z3.string().trim().min(16).max(191),
+  maximumSpendUsd: z3.number().positive().finite(),
+  maximumWallSeconds: z3.number().int().positive().max(21600)
 }).strict().superRefine((value, context) => {
   if (value.evaluationGpuType && value.mode !== "evaluation_only")
     context.addIssue({
@@ -148,56 +234,56 @@ var TrainingCheckpointRecoveryRequestSchema = z2.object({
 });
 
 // src/training-physical-placement.ts
-import { z as z3 } from "zod";
-var TrainingPhysicalPlacementSchema = z3.object({
-  mode: z3.literal("reuse_only"),
-  physicalWorkerId: z3.string().trim().min(1).max(191),
-  providerPodId: z3.string().trim().min(1).max(191),
-  workerImageDigest: z3.string().regex(/^sha256:[a-f0-9]{64}$/),
-  baseProfileSha256: z3.string().regex(/^[a-f0-9]{64}$/),
-  gpuType: z3.string().trim().min(1).max(200),
-  sourceJobId: z3.string().trim().min(1).max(191),
-  sourceInputManifestSha256: z3.string().regex(/^[a-f0-9]{64}$/),
-  ownerTeamId: z3.string().trim().min(1).max(191),
-  deadlineAt: z3.string().datetime({ offset: true })
+import { z as z4 } from "zod";
+var TrainingPhysicalPlacementSchema = z4.object({
+  mode: z4.literal("reuse_only"),
+  physicalWorkerId: z4.string().trim().min(1).max(191),
+  providerPodId: z4.string().trim().min(1).max(191),
+  workerImageDigest: z4.string().regex(/^sha256:[a-f0-9]{64}$/),
+  baseProfileSha256: z4.string().regex(/^[a-f0-9]{64}$/),
+  gpuType: z4.string().trim().min(1).max(200),
+  sourceJobId: z4.string().trim().min(1).max(191),
+  sourceInputManifestSha256: z4.string().regex(/^[a-f0-9]{64}$/),
+  ownerTeamId: z4.string().trim().min(1).max(191),
+  deadlineAt: z4.string().datetime({ offset: true })
 }).strict();
 
 // src/training-preparations.ts
-import { z as z4 } from "zod";
-var Id2 = z4.string().trim().min(1).max(191);
-var Hash = z4.string().regex(/^[a-f0-9]{64}$/);
-var TrainingPreparationRequestSchema = z4.object({
-  schemaVersion: z4.literal("openpond.trainingPreparationRequest.v1"),
-  teamId: Id2,
-  operationId: Id2,
-  projectId: Id2.nullable(),
-  configuration: z4.object({ id: Id2, expectedRevision: z4.number().int().positive(), expectedEtag: Hash }).strict(),
+import { z as z5 } from "zod";
+var Id3 = z5.string().trim().min(1).max(191);
+var Hash2 = z5.string().regex(/^[a-f0-9]{64}$/);
+var TrainingPreparationRequestSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingPreparationRequest.v1"),
+  teamId: Id3,
+  operationId: Id3,
+  projectId: Id3.nullable(),
+  configuration: z5.object({ id: Id3, expectedRevision: z5.number().int().positive(), expectedEtag: Hash2 }).strict(),
   origin: TrainingHandoffOriginSchema.optional(),
   batch: ModelProjectVersionedRefSchema,
-  name: z4.string().trim().min(1).max(191),
-  maximumSpendUsd: z4.number().finite().positive().max(1e6),
+  name: z5.string().trim().min(1).max(191),
+  maximumSpendUsd: z5.number().finite().positive().max(1e6),
   gpuSelection: TrainingGpuSelectionSchema.optional(),
   physicalPlacement: TrainingPhysicalPlacementSchema.optional()
 }).strict();
-var TrainingPreparationPlanContentSchema = z4.object({
-  schemaVersion: z4.literal("openpond.trainingPreparationPlan.v1"),
-  id: Id2,
-  creatorUserId: Id2,
+var TrainingPreparationPlanContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingPreparationPlan.v1"),
+  id: Id3,
+  creatorUserId: Id3,
   request: TrainingPreparationRequestSchema,
-  requestHash: Hash,
-  source: z4.lazy(() => TrainingJobSourceSchema),
-  submissionHash: Hash,
-  createdAt: z4.string().datetime({ offset: true })
+  requestHash: Hash2,
+  source: z5.lazy(() => TrainingJobSourceSchema),
+  submissionHash: Hash2,
+  createdAt: z5.string().datetime({ offset: true })
 }).strict();
 var TrainingPreparationPlanSchema = TrainingPreparationPlanContentSchema.extend({
-  contentHash: Hash
+  contentHash: Hash2
 }).strict();
-var TrainingPreparationReceiptSchema = z4.object({
-  schemaVersion: z4.literal("openpond.trainingPreparationReceipt.v1"),
+var TrainingPreparationReceiptSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingPreparationReceipt.v1"),
   plan: TrainingPreparationPlanSchema,
-  revision: z4.number().int().positive(),
-  state: z4.enum(["prepared", "submitted", "cancelled"]),
-  jobId: Id2.nullable()
+  revision: z5.number().int().positive(),
+  state: z5.enum(["prepared", "submitted", "cancelled"]),
+  jobId: Id3.nullable()
 }).strict().superRefine((value, context) => {
   if (value.state === "submitted" !== Boolean(value.jobId))
     context.addIssue({
@@ -206,23 +292,23 @@ var TrainingPreparationReceiptSchema = z4.object({
       message: "Only submitted preparations identify a job."
     });
 });
-var TrainingPreparationControlSchema = z4.object({
-  teamId: Id2,
-  planHash: Hash,
-  expectedRevision: z4.number().int().positive(),
+var TrainingPreparationControlSchema = z5.object({
+  teamId: Id3,
+  planHash: Hash2,
+  expectedRevision: z5.number().int().positive(),
   estimateReview: TrainingEstimateReviewSchema.optional()
 }).strict();
-var TrainingPreparationListQuerySchema = z4.object({
-  projectId: Id2.optional(),
-  state: z4.enum(["prepared", "submitted", "cancelled"]).optional(),
-  afterId: Id2.optional(),
-  limit: z4.number().int().min(1).max(100).default(25)
+var TrainingPreparationListQuerySchema = z5.object({
+  projectId: Id3.optional(),
+  state: z5.enum(["prepared", "submitted", "cancelled"]).optional(),
+  afterId: Id3.optional(),
+  limit: z5.number().int().min(1).max(100).default(25)
 }).strict();
-var TrainingPreparationPageSchema = z4.object({
-  schemaVersion: z4.literal("openpond.trainingPreparationPage.v1"),
-  teamId: Id2,
-  items: z4.array(TrainingPreparationReceiptSchema).max(100),
-  nextCursor: Id2.nullable()
+var TrainingPreparationPageSchema = z5.object({
+  schemaVersion: z5.literal("openpond.trainingPreparationPage.v1"),
+  teamId: Id3,
+  items: z5.array(TrainingPreparationReceiptSchema).max(100),
+  nextCursor: Id3.nullable()
 }).strict();
 async function parseAndVerifyTrainingPreparationReceipt(value) {
   const receipt = TrainingPreparationReceiptSchema.parse(value);
@@ -248,7 +334,7 @@ function createTrainingPreparationClient(request) {
   return {
     /** Discover the authenticated user's retained preparations without creating jobs. */
     async listPreparations(teamId, input = {}) {
-      const scope = Id2.parse(teamId);
+      const scope = Id3.parse(teamId);
       const query = TrainingPreparationListQuerySchema.parse(input);
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) params.set(key, String(value));
@@ -293,15 +379,15 @@ function createTrainingPreparationClient(request) {
     },
     async getPreparation(teamId, id2) {
       return read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id2))}`),
-        Id2.parse(teamId),
+        await request(`/v1/training/preparations/${encodeURIComponent(Id3.parse(id2))}`),
+        Id3.parse(teamId),
         id2
       );
     },
     async startPreparation(id2, input) {
       const parsed = TrainingPreparationControlSchema.parse(input);
       const receipt = await read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id2))}/start`, {
+        await request(`/v1/training/preparations/${encodeURIComponent(Id3.parse(id2))}/start`, {
           method: "POST",
           body: JSON.stringify(parsed)
         }),
@@ -318,7 +404,7 @@ function createTrainingPreparationClient(request) {
     async cancelPreparation(id2, input) {
       const parsed = TrainingPreparationControlSchema.parse(input);
       const receipt = await read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id2))}/cancel`, {
+        await request(`/v1/training/preparations/${encodeURIComponent(Id3.parse(id2))}/cancel`, {
           method: "POST",
           body: JSON.stringify(parsed)
         }),
@@ -336,31 +422,31 @@ function createTrainingPreparationClient(request) {
 }
 
 // src/training-estimates.ts
-import { z as z5 } from "zod";
-var Id3 = z5.string().trim().min(1).max(191);
-var Hash2 = z5.string().regex(/^[a-f0-9]{64}$/);
-var Timestamp = z5.string().datetime({ offset: true });
-var NonNegative = z5.number().finite().nonnegative();
-var TrainingEstimateSourceSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("preparation"), id: Id3, planHash: Hash2, expectedRevision: z5.number().int().positive() }).strict(),
-  z5.object({
-    kind: z5.literal("configuration"),
-    id: Id3,
-    expectedRevision: z5.number().int().positive(),
-    expectedEtag: Hash2,
+import { z as z6 } from "zod";
+var Id4 = z6.string().trim().min(1).max(191);
+var Hash3 = z6.string().regex(/^[a-f0-9]{64}$/);
+var Timestamp = z6.string().datetime({ offset: true });
+var NonNegative = z6.number().finite().nonnegative();
+var TrainingEstimateSourceSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("preparation"), id: Id4, planHash: Hash3, expectedRevision: z6.number().int().positive() }).strict(),
+  z6.object({
+    kind: z6.literal("configuration"),
+    id: Id4,
+    expectedRevision: z6.number().int().positive(),
+    expectedEtag: Hash3,
     batch: ModelProjectVersionedRefSchema.nullable().default(null)
   }).strict(),
-  z5.object({ kind: z5.literal("submission"), submission: z5.lazy(() => TrainingJobSubmissionSchema) }).strict()
+  z6.object({ kind: z6.literal("submission"), submission: z6.lazy(() => TrainingJobSubmissionSchema) }).strict()
 ]);
-var TrainingEstimateRequestSchema = z5.object({
-  schemaVersion: z5.literal("openpond.trainingEstimateRequest.v1"),
-  teamId: Id3,
+var TrainingEstimateRequestSchema = z6.object({
+  schemaVersion: z6.literal("openpond.trainingEstimateRequest.v1"),
+  teamId: Id4,
   source: TrainingEstimateSourceSchema,
   gpuSelection: TrainingGpuSelectionSchema.optional()
 }).strict();
-var PlanningRange = z5.object({ low: NonNegative, high: NonNegative }).strict().refine((value) => value.high >= value.low, "Planning range must be ordered");
-var TrainingEstimateComponentSchema = z5.object({
-  phase: z5.enum([
+var PlanningRange = z6.object({ low: NonNegative, high: NonNegative }).strict().refine((value) => value.high >= value.low, "Planning range must be ordered");
+var TrainingEstimateComponentSchema = z6.object({
+  phase: z6.enum([
     "startup",
     "baseline_evaluation",
     "rollouts",
@@ -372,12 +458,12 @@ var TrainingEstimateComponentSchema = z5.object({
     "cleanup",
     "retention"
   ]),
-  resource: z5.enum(["gpu", "cpu", "judge", "storage", "network"]),
+  resource: z6.enum(["gpu", "cpu", "judge", "storage", "network"]),
   expectedUsd: NonNegative.nullable(),
   expectedSeconds: NonNegative.nullable(),
   planningRangeUsd: PlanningRange.nullable(),
-  evidence: z5.enum(["measured", "configured_rate", "unavailable"]),
-  reason: z5.string().trim().min(1).max(1e3).nullable()
+  evidence: z6.enum(["measured", "configured_rate", "unavailable"]),
+  reason: z6.string().trim().min(1).max(1e3).nullable()
 }).strict();
 function trainingEstimateSourceIdentity(source) {
   if (source.kind === "submission") return {
@@ -394,64 +480,64 @@ function trainingEstimateSourceIdentity(source) {
   };
   return { kind: source.kind, id: source.id, contentHash: source.expectedEtag, revision: source.expectedRevision };
 }
-var TrainingEstimateSchema = z5.object({
-  schemaVersion: z5.literal("openpond.trainingEstimate.v1"),
-  id: Id3,
-  teamId: Id3,
-  requestHash: Hash2,
-  inputHash: Hash2,
-  source: z5.object({
-    kind: z5.enum(["preparation", "configuration", "submission"]),
-    id: Id3,
-    contentHash: Hash2,
-    revision: z5.number().int().positive().nullable()
+var TrainingEstimateSchema = z6.object({
+  schemaVersion: z6.literal("openpond.trainingEstimate.v1"),
+  id: Id4,
+  teamId: Id4,
+  requestHash: Hash3,
+  inputHash: Hash3,
+  source: z6.object({
+    kind: z6.enum(["preparation", "configuration", "submission"]),
+    id: Id4,
+    contentHash: Hash3,
+    revision: z6.number().int().positive().nullable()
   }).strict(),
-  status: z5.enum(["available", "partial", "insufficient_evidence"]),
-  currency: z5.literal("USD"),
+  status: z6.enum(["available", "partial", "insufficient_evidence"]),
+  currency: z6.literal("USD"),
   createdAt: Timestamp,
   expiresAt: Timestamp,
-  estimatorVersion: Id3,
-  runtimeVersion: Id3,
-  pricing: z5.object({ version: Id3, quoteExpiresAt: Timestamp.nullable() }).strict(),
-  gpu: z5.object({
+  estimatorVersion: Id4,
+  runtimeVersion: Id4,
+  pricing: z6.object({ version: Id4, quoteExpiresAt: Timestamp.nullable() }).strict(),
+  gpu: z6.object({
     requested: TrainingGpuSelectionSchema,
-    resolved: z5.object({ availabilityId: Id3, gpuType: z5.string().min(1).max(256), gpuCount: z5.literal(1) }).strict().nullable(),
+    resolved: z6.object({ availabilityId: Id4, gpuType: z6.string().min(1).max(256), gpuCount: z6.union([z6.literal(1), z6.literal(2)]) }).strict().nullable(),
     customerHourlyUsd: NonNegative.nullable(),
-    availability: z5.enum(["available", "limited", "unavailable", "unknown"])
+    availability: z6.enum(["available", "limited", "unavailable", "unknown"])
   }).strict(),
-  configuration: z5.object({
-    modelId: Id3,
-    modelRevision: z5.string().min(1).max(256),
-    method: Id3,
-    loraRank: z5.number().int().positive().nullable(),
-    adapterMode: z5.enum(["residual_append", "shared", "sequential_merge"]).nullable(),
-    groups: z5.number().int().nonnegative().nullable(),
-    rolloutConcurrency: z5.number().int().positive().nullable(),
-    maxOutputTokens: z5.number().int().positive().nullable(),
-    trainingRows: z5.number().int().nonnegative().nullable(),
-    evaluationRows: z5.number().int().nonnegative().nullable(),
-    retentionDays: z5.number().int().positive().nullable(),
+  configuration: z6.object({
+    modelId: Id4,
+    modelRevision: z6.string().min(1).max(256),
+    method: Id4,
+    loraRank: z6.number().int().positive().nullable(),
+    adapterMode: z6.enum(["residual_append", "shared", "sequential_merge"]).nullable(),
+    groups: z6.number().int().nonnegative().nullable(),
+    rolloutConcurrency: z6.number().int().positive().nullable(),
+    maxOutputTokens: z6.number().int().positive().nullable(),
+    trainingRows: z6.number().int().nonnegative().nullable(),
+    evaluationRows: z6.number().int().nonnegative().nullable(),
+    retentionDays: z6.number().int().positive().nullable(),
     approvedMaximumUsd: NonNegative.nullable()
   }).strict(),
-  cost: z5.object({
+  cost: z6.object({
     expectedUsd: NonNegative.nullable(),
     planningRangeUsd: PlanningRange.nullable(),
     knownMinimumUsd: NonNegative,
     recommendedMaximumUsd: NonNegative.nullable(),
     minimumCleanupReserveUsd: NonNegative.nullable(),
-    components: z5.array(TrainingEstimateComponentSchema).max(50)
+    components: z6.array(TrainingEstimateComponentSchema).max(50)
   }).strict(),
-  executionSeconds: z5.object({ expected: NonNegative.nullable(), planningRange: PlanningRange.nullable() }).strict(),
-  queueWaitSeconds: z5.object({ expected: NonNegative, planningRange: PlanningRange.nullable() }).strict().nullable(),
-  calibration: z5.object({
-    version: Id3,
-    cohortHash: Hash2,
-    completedSamples: z5.number().int().nonnegative(),
-    partialSamples: z5.number().int().nonnegative(),
-    scope: z5.enum(["workspace", "authorized_aggregate"])
+  executionSeconds: z6.object({ expected: NonNegative.nullable(), planningRange: PlanningRange.nullable() }).strict(),
+  queueWaitSeconds: z6.object({ expected: NonNegative, planningRange: PlanningRange.nullable() }).strict().nullable(),
+  calibration: z6.object({
+    version: Id4,
+    cohortHash: Hash3,
+    completedSamples: z6.number().int().nonnegative(),
+    partialSamples: z6.number().int().nonnegative(),
+    scope: z6.enum(["workspace", "authorized_aggregate"])
   }).strict(),
-  assumptions: z5.array(z5.string().trim().min(1).max(1e3)).max(50),
-  unknowns: z5.array(z5.string().trim().min(1).max(1e3)).max(50),
+  assumptions: z6.array(z6.string().trim().min(1).max(1e3)).max(50),
+  unknowns: z6.array(z6.string().trim().min(1).max(1e3)).max(50),
   review: TrainingEstimateReviewSchema
 }).strict().superRefine((estimate, context) => {
   if (estimate.review.estimateId !== estimate.id || estimate.review.inputHash !== estimate.inputHash || estimate.review.requestHash !== estimate.requestHash || estimate.review.pricingVersion !== estimate.pricing.version || estimate.review.expiresAt !== estimate.expiresAt) {
@@ -466,6 +552,9 @@ var TrainingEstimateSchema = z5.object({
   if (estimate.gpu.requested.mode === "manual" && estimate.gpu.resolved && (estimate.gpu.requested.availabilityId !== estimate.gpu.resolved.availabilityId || estimate.gpu.requested.gpuType !== estimate.gpu.resolved.gpuType)) {
     context.addIssue({ code: "custom", path: ["gpu"], message: "An explicit GPU offering cannot be substituted" });
   }
+  if (estimate.gpu.resolved && estimate.gpu.resolved.gpuCount !== (estimate.gpu.requested.gpuCount ?? 1)) {
+    context.addIssue({ code: "custom", path: ["gpu", "resolved", "gpuCount"], message: "The resolved GPU count must match the requested count" });
+  }
 });
 function createTrainingEstimateClient(request) {
   return {
@@ -485,21 +574,21 @@ function createTrainingEstimateClient(request) {
 }
 
 // src/training-queue.ts
-import { z as z6 } from "zod";
-var Timestamp2 = z6.string().datetime({ offset: true });
-var TrainingQueueStatusSchema = z6.object({
-  ticketId: z6.string().trim().min(1).max(191),
-  ticketNumber: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  label: z6.literal("Waiting for resources"),
-  position: z6.number().int().positive().nullable(),
-  positionScope: z6.literal("compatible_fair_queue"),
+import { z as z7 } from "zod";
+var Timestamp2 = z7.string().datetime({ offset: true });
+var TrainingQueueStatusSchema = z7.object({
+  ticketId: z7.string().trim().min(1).max(191),
+  ticketNumber: z7.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  label: z7.literal("Waiting for resources"),
+  position: z7.number().int().positive().nullable(),
+  positionScope: z7.literal("compatible_fair_queue"),
   enqueuedAt: Timestamp2,
   asOf: Timestamp2,
-  estimate: z6.object({
-    revision: z6.number().int().nonnegative(),
+  estimate: z7.object({
+    revision: z7.number().int().nonnegative(),
     estimatedStartAt: Timestamp2,
     expiresAt: Timestamp2,
-    evidence: z6.enum(["observed_capacity", "measured_bootstrap", "scheduled_release"])
+    evidence: z7.enum(["observed_capacity", "measured_bootstrap", "scheduled_release"])
   }).strict().nullable()
 }).strict().superRefine((value, context) => {
   if (value.estimate && Date.parse(value.estimate.expiresAt) <= Date.parse(value.asOf))
@@ -507,12 +596,12 @@ var TrainingQueueStatusSchema = z6.object({
 });
 
 // src/training-harness-sources.ts
-import { z as z7 } from "zod";
-var TrainingHarnessSourcePublicationSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingHarnessSourcePublication.v1"),
+import { z as z8 } from "zod";
+var TrainingHarnessSourcePublicationSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingHarnessSourcePublication.v1"),
   harnessRelease: ImmutableReleaseRefSchema,
-  sourcePackageHash: z7.string().regex(/^[a-f0-9]{64}$/),
-  sizeBytes: z7.number().int().positive().max(TRAINING_INPUT_ARTIFACT_MAX_BYTES)
+  sourcePackageHash: z8.string().regex(/^[a-f0-9]{64}$/),
+  sizeBytes: z8.number().int().positive().max(TRAINING_INPUT_ARTIFACT_MAX_BYTES)
 }).strict();
 function createTrainingHarnessSourceClient(request) {
   const route = (reference) => {
@@ -545,28 +634,28 @@ function validateSource(value, reference) {
 }
 
 // src/training-candidate-decisions.ts
-import { z as z8 } from "zod";
-var IdSchema = /* @__PURE__ */ (() => z8.string().trim().min(1).max(500))();
-var HashSchema = /* @__PURE__ */ (() => z8.string().regex(/^[a-f0-9]{64}$/))();
-var TrainingCandidateDecisionRequestSchema = /* @__PURE__ */ (() => z8.object({
-  schemaVersion: z8.literal("openpond.trainingCandidateDecisionRequest.v1"),
+import { z as z9 } from "zod";
+var IdSchema = /* @__PURE__ */ (() => z9.string().trim().min(1).max(500))();
+var HashSchema = /* @__PURE__ */ (() => z9.string().regex(/^[a-f0-9]{64}$/))();
+var TrainingCandidateDecisionRequestSchema = /* @__PURE__ */ (() => z9.object({
+  schemaVersion: z9.literal("openpond.trainingCandidateDecisionRequest.v1"),
   teamId: IdSchema,
   jobId: IdSchema,
   artifact: ModelProjectImmutableRefSchema,
   evaluation: ModelProjectImmutableRefSchema,
   executionReceipt: ModelProjectImmutableRefSchema,
-  decision: z8.enum(["accepted", "rejected"]),
-  reason: z8.string().trim().min(1).max(5e3),
+  decision: z9.enum(["accepted", "rejected"]),
+  reason: z9.string().trim().min(1).max(5e3),
   idempotencyKey: IdSchema,
   expectedDecision: ModelProjectImmutableRefSchema.nullable()
 }).strict())();
-var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z8.object({
-  schemaVersion: z8.literal("openpond.trainingCandidateDecision.v1"),
+var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z9.object({
+  schemaVersion: z9.literal("openpond.trainingCandidateDecision.v1"),
   id: IdSchema,
   request: TrainingCandidateDecisionRequestSchema,
-  revision: z8.number().int().positive(),
-  actor: z8.object({ userId: IdSchema, kind: z8.enum(["user", "api_key", "agent_delegate"]), id: IdSchema }).strict(),
-  decidedAt: z8.string().datetime({ offset: true }),
+  revision: z9.number().int().positive(),
+  actor: z9.object({ userId: IdSchema, kind: z9.enum(["user", "api_key", "agent_delegate"]), id: IdSchema }).strict(),
+  decidedAt: z9.string().datetime({ offset: true }),
   contentHash: HashSchema
 }).strict().superRefine((value, context) => {
   if (value.revision === 1 !== (value.request.expectedDecision === null)) {
@@ -603,7 +692,7 @@ function createTrainingCandidateDecisionClient(request) {
       IdSchema.parse(target.teamId);
       const reference = options.decision ? ModelProjectImmutableRefSchema.parse(options.decision) : void 0;
       const query = reference ? `?decisionId=${encodeURIComponent(reference.id)}` : "";
-      const response = z8.object({ decision: z8.unknown().nullable() }).strict().parse(await request(`${route(target)}${query}`));
+      const response = z9.object({ decision: z9.unknown().nullable() }).strict().parse(await request(`${route(target)}${query}`));
       if (response.decision === null && !reference) return null;
       const decision = await parseAndVerifyTrainingCandidateDecision(response.decision, target);
       if (reference && (decision.id !== reference.id || decision.contentHash !== reference.contentHash)) {
@@ -620,38 +709,38 @@ function createTrainingCandidateDecisionClient(request) {
 }
 
 // src/training-evaluation-results.ts
-import { z as z9 } from "zod";
-var IdSchema2 = /* @__PURE__ */ (() => z9.string().trim().min(1).max(500))();
-var HashSchema2 = /* @__PURE__ */ (() => z9.string().regex(/^[a-f0-9]{64}$/))();
-var TrainingEvaluationTaskResultSchema = /* @__PURE__ */ (() => z9.object({
+import { z as z10 } from "zod";
+var IdSchema2 = /* @__PURE__ */ (() => z10.string().trim().min(1).max(500))();
+var HashSchema2 = /* @__PURE__ */ (() => z10.string().regex(/^[a-f0-9]{64}$/))();
+var TrainingEvaluationTaskResultSchema = /* @__PURE__ */ (() => z10.object({
   taskId: IdSchema2,
   taskSha256: HashSchema2,
   resultSha256: HashSchema2,
-  input: z9.object({
-    instruction: z9.string().max(1e6),
-    context: z9.record(z9.string(), z9.unknown())
+  input: z10.object({
+    instruction: z10.string().max(1e6),
+    context: z10.record(z10.string(), z10.unknown())
   }).strict(),
-  output: z9.string().max(1e6),
+  output: z10.string().max(1e6),
   outputSha256: HashSchema2,
-  score: z9.number().finite().min(0).max(1),
-  evidence: z9.object({
-    kind: z9.enum(["worker_command", "hosted_trace", "local_trace"]),
+  score: z10.number().finite().min(0).max(1),
+  evidence: z10.object({
+    kind: z10.enum(["worker_command", "hosted_trace", "local_trace"]),
     id: IdSchema2
   }).strict()
 }).strict())();
-var TrainingEvaluationTaskPageSchema = /* @__PURE__ */ (() => z9.object({
-  schemaVersion: z9.literal("openpond.trainingEvaluationTaskPage.v1"),
+var TrainingEvaluationTaskPageSchema = /* @__PURE__ */ (() => z10.object({
+  schemaVersion: z10.literal("openpond.trainingEvaluationTaskPage.v1"),
   jobId: IdSchema2,
   teamId: IdSchema2,
   evaluation: ModelProjectImmutableRefSchema,
-  kind: z9.enum(["baseline", "candidate"]),
-  policyVersion: z9.number().int().nonnegative(),
+  kind: z10.enum(["baseline", "candidate"]),
+  policyVersion: z10.number().int().nonnegative(),
   taskset: ModelProjectVersionedRefSchema,
   panelSha256: HashSchema2,
-  offset: z9.number().int().nonnegative(),
-  total: z9.number().int().min(1).max(1e4),
-  tasks: z9.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
-  nextCursor: z9.string().regex(/^[1-9]\d*$/).nullable(),
+  offset: z10.number().int().nonnegative(),
+  total: z10.number().int().min(1).max(1e4),
+  tasks: z10.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
+  nextCursor: z10.string().regex(/^[1-9]\d*$/).nullable(),
   contentHash: HashSchema2
 }).strict().superRefine((page, context) => {
   const end = page.offset + page.tasks.length;
@@ -686,12 +775,12 @@ async function parseAndVerifyTrainingEvaluationTaskPage(value, expected) {
 }
 
 // src/training-grading-plan.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import { compileBoundGraders, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
-var GradersSchema = z10.array(z10.object({ id: z10.string().trim().min(1) }).catchall(z10.unknown())).min(1).max(1e3);
-var RewardExecutionSchema = z10.object({
+var GradersSchema = z11.array(z11.object({ id: z11.string().trim().min(1) }).catchall(z11.unknown())).min(1).max(1e3);
+var RewardExecutionSchema = z11.object({
   binding: RewardBindingSchema,
-  rewards: z10.array(RewardReleaseSchema).min(1).max(100)
+  rewards: z11.array(RewardReleaseSchema).min(1).max(100)
 }).strict();
 async function deterministicTrainingRewardSource(input) {
   const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
@@ -708,23 +797,23 @@ async function deterministicTrainingRewardSource(input) {
 }
 
 // src/training-evaluation-source.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var TRAINING_EVALUATION_SOURCE_PATH = "evaluation-source.json";
-var TaskIdentitySchema = z11.object({
-  id: z11.string().trim().min(1),
-  clusterKey: z11.string().trim().min(1),
-  split: z11.enum(["train", "validation", "frozen_eval"])
+var TaskIdentitySchema = z12.object({
+  id: z12.string().trim().min(1),
+  clusterKey: z12.string().trim().min(1),
+  split: z12.enum(["train", "validation", "frozen_eval"])
 }).passthrough();
-var TrainingEvaluationSourceSchema = z11.object({
-  schemaVersion: z11.literal("openpond.trainingEvaluationSource.v1"),
+var TrainingEvaluationSourceSchema = z12.object({
+  schemaVersion: z12.literal("openpond.trainingEvaluationSource.v1"),
   taskset: ModelProjectVersionedRefSchema,
-  tasks: z11.array(TaskIdentitySchema).min(1).max(1e4),
-  assets: z11.array(z11.object({
-    path: z11.string().trim().min(1).max(2e3),
-    sha256: z11.string().regex(/^[a-f0-9]{64}$/),
-    sizeBytes: z11.number().int().nonnegative(),
-    encoding: z11.literal("base64"),
-    content: z11.string().max(32 * 1024 * 1024)
+  tasks: z12.array(TaskIdentitySchema).min(1).max(1e4),
+  assets: z12.array(z12.object({
+    path: z12.string().trim().min(1).max(2e3),
+    sha256: z12.string().regex(/^[a-f0-9]{64}$/),
+    sizeBytes: z12.number().int().nonnegative(),
+    encoding: z12.literal("base64"),
+    content: z12.string().max(32 * 1024 * 1024)
   }).strict()).max(1e4)
 }).strict().superRefine((source, context) => {
   const ids = /* @__PURE__ */ new Set();
@@ -735,8 +824,8 @@ var TrainingEvaluationSourceSchema = z11.object({
   });
 });
 function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
-  const training = z11.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
-  const evaluation = z11.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
+  const training = z12.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
+  const evaluation = z12.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
   const trainIds = /* @__PURE__ */ new Set();
   const trainFamilies = /* @__PURE__ */ new Set();
   for (const task of training) {
@@ -762,24 +851,24 @@ async function trainingEvaluationSourceRef(input) {
 }
 
 // src/training.ts
-var IdSchema3 = z12.string().trim().min(1).max(500);
-var HashSchema3 = z12.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z12.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z12.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z12.string().trim().min(1).max(500),
+var IdSchema3 = z13.string().trim().min(1).max(500);
+var HashSchema3 = z13.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema = z13.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z13.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z13.string().trim().min(1).max(500),
   sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z12.unknown(),
+  payload: z13.unknown(),
   contentHash: HashSchema3
 }).strict();
-var TrainingInputArtifactSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingInputArtifact.v2"),
-  kind: z12.enum(["portable_training_bundle", "reward_model_dataset"]),
+var TrainingInputArtifactSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingInputArtifact.v2"),
+  kind: z13.enum(["portable_training_bundle", "reward_model_dataset"]),
   sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z12.string().trim().min(1).max(2e3),
+  artifactRef: z13.string().trim().min(1).max(2e3),
   contentHash: HashSchema3,
-  sizeBytes: z12.number().int().positive(),
+  sizeBytes: z13.number().int().positive(),
   createdAt: TimestampSchema
 }).strict();
 async function trainingInputArtifactUploadHash(upload) {
@@ -798,8 +887,8 @@ async function parseAndVerifyTrainingInputArtifactUpload(value) {
   }
   return parsed;
 }
-var TrainingJobKindSchema = z12.enum(["reward_model_train", "policy_optimize"]);
-var TrainingJobStateSchema = z12.enum([
+var TrainingJobKindSchema = z13.enum(["reward_model_train", "policy_optimize"]);
+var TrainingJobStateSchema = z13.enum([
   "queued",
   "admitting",
   "provisioning",
@@ -810,53 +899,53 @@ var TrainingJobStateSchema = z12.enum([
   "failed",
   "cancelled"
 ]);
-var TrainingCapabilityRequirementSchema = z12.object({
+var TrainingCapabilityRequirementSchema = z13.object({
   id: IdSchema3,
-  version: z12.string().trim().min(1).max(200).nullable().default(null),
-  required: z12.boolean().default(true)
+  version: z13.string().trim().min(1).max(200).nullable().default(null),
+  required: z13.boolean().default(true)
 }).strict();
-var TrainingJobSourceSchema = z12.object({
+var TrainingJobSourceSchema = z13.object({
   origin: TrainingHandoffOriginSchema.optional(),
-  modelProject: z12.object({
+  modelProject: z13.object({
     id: IdSchema3,
     portableProjectId: IdSchema3,
-    revision: z12.number().int().positive(),
+    revision: z13.number().int().positive(),
     contentHash: HashSchema3
   }).strict(),
   harnessRunManifest: ModelProjectImmutableRefSchema,
   harnessRelease: ModelProjectImmutableRefSchema,
   taskset: ModelProjectVersionedRefSchema,
   tasksetRelease: ModelProjectImmutableRefSchema,
-  evaluation: z12.object({
+  evaluation: z13.object({
     taskset: ModelProjectVersionedRefSchema,
     dataset: ModelProjectImmutableRefSchema
   }).strict().nullable().optional(),
   dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z12.array(ModelProjectImmutableRefSchema).max(1e4)
+  evidenceSets: z13.array(ModelProjectImmutableRefSchema).max(1e4)
 }).strict();
-var RewardModelTrainingRequestSchema = z12.object({
-  kind: z12.literal("reward_model_train"),
+var RewardModelTrainingRequestSchema = z13.object({
+  kind: z13.literal("reward_model_train"),
   baseModel: ModelProjectBaseModelSchema,
   preferenceDatasetRelease: ModelProjectImmutableRefSchema,
   processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z12.object({
-    schemaVersion: z12.literal("openpond.rewardModelRecipe.v1"),
-    method: z12.literal("reward_model"),
-    parameterization: z12.literal("lora_with_scalar_head")
-  }).catchall(z12.unknown())
+  recipe: z13.object({
+    schemaVersion: z13.literal("openpond.rewardModelRecipe.v1"),
+    method: z13.literal("reward_model"),
+    parameterization: z13.literal("lora_with_scalar_head")
+  }).catchall(z13.unknown())
 }).strict();
-var DeterministicRewardSourceSchema = z12.object({
-  kind: z12.literal("deterministic"),
+var DeterministicRewardSourceSchema = z13.object({
+  kind: z13.literal("deterministic"),
   grader: ModelProjectImmutableRefSchema,
   composer: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var LearnedRewardSourceSchema = z12.object({
-  kind: z12.literal("learned_reward"),
+var LearnedRewardSourceSchema = z13.object({
+  kind: z13.literal("learned_reward"),
   rewardModelVersion: ModelProjectImmutableRefSchema,
   qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z12.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z12.object({
-    artifactRef: z12.string().trim().min(1).max(2e3),
+  evaluationReferences: z13.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z13.object({
+    artifactRef: z13.string().trim().min(1).max(2e3),
     contentHash: HashSchema3,
     executionReceipt: ModelProjectImmutableRefSchema
   }).strict(),
@@ -864,51 +953,81 @@ var LearnedRewardSourceSchema = z12.object({
   rewardComposerRelease: ModelProjectImmutableRefSchema
 }).strict();
 var TrainingQualificationBaseModelSchema = ModelProjectBaseModelSchema.extend({
-  revision: z12.string().regex(/^[a-f0-9]{40,64}$/),
-  tokenizerRevision: z12.string().regex(/^[a-f0-9]{40,64}$/),
+  revision: z13.string().regex(/^[a-f0-9]{40,64}$/),
+  tokenizerRevision: z13.string().regex(/^[a-f0-9]{40,64}$/),
   chatTemplateHash: HashSchema3
 }).strict();
-var PolicyOptimizationRequestSchema = z12.object({
-  kind: z12.literal("policy_optimize"),
+var PolicyOptimizationRequestSchema = z13.object({
+  kind: z13.literal("policy_optimize"),
   /** Collect and grade one original-learner group without optimizer work. */
-  executionMode: z12.literal("qualification").optional(),
+  executionMode: z13.literal("qualification").optional(),
   baseModel: ModelProjectBaseModelSchema,
   recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z12.discriminatedUnion("kind", [
+  rewardSource: z13.discriminatedUnion("kind", [
     DeterministicRewardSourceSchema,
     LearnedRewardSourceSchema
   ]),
   resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
-}).strict();
-var TrainingJobRequestSchema = z12.discriminatedUnion("kind", [
+}).strict().superRefine((job, context) => {
+  if (job.recipe.method !== "sft") return;
+  const recipe = SftRecipeSchema.safeParse(job.recipe);
+  if (!recipe.success) {
+    context.addIssue({
+      code: "custom",
+      path: ["recipe"],
+      message: "The SFT recipe is incomplete or invalid."
+    });
+    return;
+  }
+  if (job.executionMode || job.resumeFrom || "continuation" in job.recipe)
+    context.addIssue({
+      code: "custom",
+      message: "Initial managed SFT requires a fresh supervised run without rollout qualification or continuation."
+    });
+  if (recipe.data.baseModel.id !== job.baseModel.modelId || recipe.data.baseModel.revision !== job.baseModel.revision || recipe.data.baseModel.tokenizerRevision !== job.baseModel.tokenizerRevision || recipe.data.baseModel.chatTemplateHash !== job.baseModel.chatTemplateHash)
+    context.addIssue({
+      code: "custom",
+      path: ["baseModel"],
+      message: "The SFT recipe must pin the exact submitted base and tokenizer."
+    });
+});
+var TrainingJobRequestSchema = z13.discriminatedUnion("kind", [
   RewardModelTrainingRequestSchema,
   PolicyOptimizationRequestSchema
 ]);
-var TrainingJobApprovalSchema = z12.object({
+var TrainingJobApprovalSchema = z13.object({
   approvalHash: HashSchema3,
   approvedAt: TimestampSchema,
-  exportApproved: z12.boolean(),
-  maximumSpendUsd: z12.number().nonnegative(),
-  retentionDays: z12.number().int().nonnegative().nullable(),
-  region: z12.string().trim().min(1).max(200).nullable().default(null)
+  exportApproved: z13.boolean(),
+  maximumSpendUsd: z13.number().nonnegative(),
+  retentionDays: z13.number().int().nonnegative().nullable(),
+  region: z13.string().trim().min(1).max(200).nullable().default(null)
 }).strict();
-var TrainingJobSubmissionSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z12.string().trim().min(1).max(500),
-  name: z12.string().trim().min(1).max(200),
+var TrainingJobSubmissionSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z13.string().trim().min(1).max(500),
+  name: z13.string().trim().min(1).max(200),
   source: TrainingJobSourceSchema,
   job: TrainingJobRequestSchema,
-  requestedCapabilities: z12.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z12.enum(["fast", "balanced", "economical"]),
+  requestedCapabilities: z13.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z13.enum(["fast", "balanced", "economical"]),
   gpuSelection: TrainingGpuSelectionSchema.optional(),
   physicalPlacement: TrainingPhysicalPlacementSchema.optional(),
-  budget: z12.object({
-    maximumSpendUsd: z12.number().nonnegative(),
-    maximumWallSeconds: z12.number().int().positive()
+  budget: z13.object({
+    maximumSpendUsd: z13.number().nonnegative(),
+    maximumWallSeconds: z13.number().int().positive()
   }).strict(),
   approval: TrainingJobApprovalSchema,
   contentHash: HashSchema3
 }).strict().superRefine((submission, context) => {
+  const distributed = (submission.gpuSelection?.gpuCount ?? 1) === 2;
+  const distributedRequirement = submission.requestedCapabilities.some((requirement) => requirement.id === "managed_rl.policy.data_parallel" && requirement.version === "1" && requirement.required);
+  if (distributed !== distributedRequirement) {
+    context.addIssue({ code: "custom", path: ["requestedCapabilities"], message: "Two-GPU training must require managed_rl.policy.data_parallel@1 and bind gpuSelection.gpuCount to 2." });
+  }
+  if (distributed && (submission.job.kind !== "policy_optimize" || submission.job.executionMode || submission.job.recipe.method !== "grpo" || submission.physicalPlacement)) {
+    context.addIssue({ code: "custom", path: ["gpuSelection"], message: "Two-GPU execution requires exclusive GRPO policy training." });
+  }
   if (submission.physicalPlacement && (submission.job.kind !== "policy_optimize" || submission.job.resumeFrom || submission.job.executionMode || submission.job.recipe.continuation !== void 0)) {
     context.addIssue({ code: "custom", path: ["physicalPlacement"], message: "Reuse-only placement requires fresh-base policy training without continuation." });
   }
@@ -956,99 +1075,99 @@ async function parseAndVerifyTrainingJobSubmission(value) {
   }
   return parsed;
 }
-var TrainingJobRecoverySchema = z12.object({
+var TrainingJobRecoverySchema = z13.object({
   resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
-  mode: z12.literal("evaluation_only").optional(),
-  trainingWorkloadComplete: z12.boolean().optional(),
+  mode: z13.literal("evaluation_only").optional(),
+  trainingWorkloadComplete: z13.boolean().optional(),
   sourceJobId: IdSchema3,
   checkpointId: IdSchema3,
-  policyVersion: z12.number().int().positive(),
-  completedGroups: z12.number().int().positive(),
-  optimizerMode: z12.literal("continue")
+  policyVersion: z13.number().int().positive(),
+  completedGroups: z13.number().int().positive(),
+  optimizerMode: z13.literal("continue")
 }).strict();
-var TrainingJobSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJob.v2"),
+var TrainingJobSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJob.v2"),
   id: IdSchema3,
   teamId: IdSchema3,
   kind: TrainingJobKindSchema,
-  executionMode: z12.literal("qualification").optional(),
+  executionMode: z13.literal("qualification").optional(),
   recovery: TrainingJobRecoverySchema.optional(),
   modelProjectId: IdSchema3,
   portableProjectId: IdSchema3,
-  sourceProjectRevision: z12.number().int().positive(),
+  sourceProjectRevision: z13.number().int().positive(),
   submissionHash: HashSchema3,
   state: TrainingJobStateSchema,
   queue: TrainingQueueStatusSchema.optional(),
-  phase: z12.string().trim().min(1).max(200),
-  version: z12.number().int().nonnegative(),
-  progress: z12.number().min(0).max(1),
-  rolloutProgress: z12.object({
-    groupsCompleted: z12.number().int().nonnegative(),
-    groupsTarget: z12.number().int().nonnegative(),
-    optimizerUpdatesApplied: z12.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z12.number().int().nonnegative()
+  phase: z13.string().trim().min(1).max(200),
+  version: z13.number().int().nonnegative(),
+  progress: z13.number().min(0).max(1),
+  rolloutProgress: z13.object({
+    groupsCompleted: z13.number().int().nonnegative(),
+    groupsTarget: z13.number().int().nonnegative(),
+    optimizerUpdatesApplied: z13.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z13.number().int().nonnegative()
   }).strict(),
-  accruedSpendUsd: z12.number().nonnegative(),
-  terminalReason: z12.string().trim().min(1).max(5e3).nullable(),
+  accruedSpendUsd: z13.number().nonnegative(),
+  terminalReason: z13.string().trim().min(1).max(5e3).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema,
   completedAt: TimestampSchema.nullable()
 }).strict();
-var TrainingJobPageSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJobPage.v2"),
-  jobs: z12.array(TrainingJobSchema).max(1e3),
-  nextCursor: z12.string().trim().min(1).max(2e3).nullable()
+var TrainingJobPageSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJobPage.v2"),
+  jobs: z13.array(TrainingJobSchema).max(1e3),
+  nextCursor: z13.string().trim().min(1).max(2e3).nullable()
 }).strict();
-var TrainingJobEventSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJobEvent.v2"),
+var TrainingJobEventSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJobEvent.v2"),
   id: IdSchema3,
   jobId: IdSchema3,
-  sequence: z12.number().int().nonnegative(),
+  sequence: z13.number().int().nonnegative(),
   type: IdSchema3,
-  phase: z12.string().trim().min(1).max(200),
-  message: z12.string().trim().min(1).max(5e3).nullable(),
-  data: z12.record(z12.string(), z12.unknown()).default({}),
+  phase: z13.string().trim().min(1).max(200),
+  message: z13.string().trim().min(1).max(5e3).nullable(),
+  data: z13.record(z13.string(), z13.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobLogSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJobLog.v2"),
+var TrainingJobLogSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJobLog.v2"),
   jobId: IdSchema3,
-  sequence: z12.number().int().nonnegative(),
-  level: z12.enum(["debug", "info", "warning", "error"]),
-  message: z12.string().max(2e4),
+  sequence: z13.number().int().nonnegative(),
+  level: z13.enum(["debug", "info", "warning", "error"]),
+  message: z13.string().max(2e4),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobControlRequestSchema = z12.object({ expectedVersion: z12.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJobOutput.v2"),
+var TrainingJobControlRequestSchema = z13.object({ expectedVersion: z13.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJobOutput.v2"),
   id: IdSchema3,
   jobId: IdSchema3,
-  kind: z12.enum(["checkpoint", "adapter", "scorer", "metrics", "evaluation", "trace", "receipt"]),
-  artifactRef: z12.string().trim().min(1).max(2e3),
+  kind: z13.enum(["checkpoint", "adapter", "scorer", "metrics", "evaluation", "trace", "receipt"]),
+  artifactRef: z13.string().trim().min(1).max(2e3),
   contentHash: HashSchema3,
-  sizeBytes: z12.number().int().nonnegative(),
-  metadata: z12.record(z12.string(), z12.unknown()).default({}),
+  sizeBytes: z13.number().int().nonnegative(),
+  metadata: z13.record(z13.string(), z13.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingQualificationEvidenceSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingQualificationEvidence.v1"),
+var TrainingQualificationEvidenceSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingQualificationEvidence.v1"),
   baseModel: TrainingQualificationBaseModelSchema,
   group: ModelProjectImmutableRefSchema,
-  rolloutReceipts: z12.array(ModelProjectImmutableRefSchema).min(1).max(1e3),
+  rolloutReceipts: z13.array(ModelProjectImmutableRefSchema).min(1).max(1e3),
   rewardEvidenceHash: HashSchema3,
-  groupsCompleted: z12.literal(1),
-  optimizerUpdatesApplied: z12.literal(0),
-  optimizerUpdatesSkipped: z12.literal(0),
-  trainingStepsCreated: z12.literal(0),
-  checkpointsCreated: z12.literal(0),
-  artifactsCreated: z12.literal(0)
+  groupsCompleted: z13.literal(1),
+  optimizerUpdatesApplied: z13.literal(0),
+  optimizerUpdatesSkipped: z13.literal(0),
+  trainingStepsCreated: z13.literal(0),
+  checkpointsCreated: z13.literal(0),
+  artifactsCreated: z13.literal(0)
 }).strict().superRefine((evidence, context) => {
   if (new Set(evidence.rolloutReceipts.map((receipt) => receipt.id)).size !== evidence.rolloutReceipts.length) {
     context.addIssue({ code: "custom", path: ["rolloutReceipts"], message: "Qualification rollout receipt identities must be unique." });
   }
 });
-var TrainingExecutionReceiptSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingExecutionReceipt.v2"),
+var TrainingExecutionReceiptSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingExecutionReceipt.v2"),
   id: IdSchema3,
   teamId: IdSchema3,
   jobId: IdSchema3,
@@ -1057,15 +1176,15 @@ var TrainingExecutionReceiptSchema = z12.object({
   recipeHash: HashSchema3,
   capabilityHash: HashSchema3,
   runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z12.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z12.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z12.number().nonnegative(),
-  durationSeconds: z12.number().nonnegative(),
-  cleanupComplete: z12.boolean(),
+  inputs: z13.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z13.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z13.number().nonnegative(),
+  durationSeconds: z13.number().nonnegative(),
+  cleanupComplete: z13.boolean(),
   qualification: TrainingQualificationEvidenceSchema.optional(),
   issuer: IdSchema3,
   issuedAt: TimestampSchema,
-  signature: z12.string().trim().min(1).max(1e4).nullable()
+  signature: z13.string().trim().min(1).max(1e4).nullable()
 }).strict();
 async function trainingExecutionReceiptHash(receipt) {
   return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
@@ -1120,46 +1239,22 @@ async function assertTrainingQualificationReceipt(receipt, expected) {
     throw new OpenPondProtocolError("qualification_updated_artifact", "Qualification must not publish trained artifacts or checkpoints.");
   }
 }
-var TrainingJobOutputsSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z12.array(TrainingJobOutputSchema).max(1e4),
+var TrainingJobOutputsSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z13.array(TrainingJobOutputSchema).max(1e4),
   receipt: TrainingExecutionReceiptSchema.nullable()
 }).strict();
-var TrainingApiErrorSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingApiError.v2"),
-  code: z12.string().trim().min(1).max(200),
-  message: z12.string().trim().min(1).max(5e3),
-  retryable: z12.boolean().default(false),
-  requestId: z12.string().trim().min(1).max(500).nullable().default(null),
-  details: z12.record(z12.string(), z12.unknown()).default({})
-}).strict();
-var OpenPondTrainingApiError = class extends Error {
-  status;
-  code;
-  retryable;
-  requestId;
-  details;
-  constructor(status, error) {
-    super(error.message);
-    this.name = "OpenPondTrainingApiError";
-    this.status = status;
-    this.code = error.code;
-    this.retryable = error.retryable;
-    this.requestId = error.requestId;
-    this.details = error.details;
-  }
-};
-var TrainingPolicyLoraCapabilitiesSchema = z12.object({
-  workerImageDigest: z12.string().regex(/^sha256:[a-f0-9]{64}$/),
-  envelopeRank: z12.number().int().positive().max(256),
-  supportedRanks: z12.array(z12.number().int().positive().max(256)).max(256),
-  qualification: z12.object({ evidenceRef: z12.string().min(1), evidenceSha256: HashSchema3 }).strict().nullable(),
-  continuation: z12.object({
-    sharedRequiresSameRank: z12.literal(true),
-    mergedRequiresSameRank: z12.literal(true),
-    residualAppendRequiresFreeCapacity: z12.literal(true),
-    stageOptimizer: z12.literal("reset"),
-    interruptedRecoveryOptimizer: z12.literal("restore")
+var TrainingPolicyLoraCapabilitiesSchema = z13.object({
+  workerImageDigest: z13.string().regex(/^sha256:[a-f0-9]{64}$/),
+  envelopeRank: z13.number().int().positive().max(256),
+  supportedRanks: z13.array(z13.number().int().positive().max(256)).max(256),
+  qualification: z13.object({ evidenceRef: z13.string().min(1), evidenceSha256: HashSchema3 }).strict().nullable(),
+  continuation: z13.object({
+    sharedRequiresSameRank: z13.literal(true),
+    mergedRequiresSameRank: z13.literal(true),
+    residualAppendRequiresFreeCapacity: z13.literal(true),
+    stageOptimizer: z13.literal("reset"),
+    interruptedRecoveryOptimizer: z13.literal("restore")
   }).strict()
 }).strict().superRefine((value, context) => {
   if (new Set(value.supportedRanks).size !== value.supportedRanks.length || value.supportedRanks.some((rank) => rank > value.envelopeRank))
@@ -1172,88 +1267,54 @@ function supportsTrainingPolicyLoraRank(capabilities, rank, continuation) {
   if (!continuation) return true;
   return continuation.mode === "residual_append" ? continuation.parentEnabledRank + rank <= capabilities.envelopeRank : continuation.parentEnabledRank === rank;
 }
-var TrainingCapabilitiesSchema = z12.object({
-  schemaVersion: z12.literal("openpond.trainingCapabilities.v2"),
+var TrainingCapabilitiesSchema = z13.object({
+  schemaVersion: z13.literal("openpond.trainingCapabilities.v2"),
   capabilityHash: HashSchema3,
-  jobKinds: z12.array(TrainingJobKindSchema),
-  methods: z12.array(z12.string().trim().min(1).max(200)),
-  executionModes: z12.array(z12.enum(["training", "qualification"])).optional(),
+  jobKinds: z13.array(TrainingJobKindSchema),
+  methods: z13.array(z13.string().trim().min(1).max(200)),
+  executionModes: z13.array(z13.enum(["training", "qualification"])).optional(),
   policyLora: TrainingPolicyLoraCapabilitiesSchema.optional(),
-  structuredOutputs: z12.object({
-    capability: z12.literal("work.structured-output.v1"),
+  policyDataParallel: z13.object({
+    capability: z13.literal("managed_rl.policy.data_parallel"),
+    version: z13.literal("1"),
+    gpuCount: z13.literal(2),
+    worldSize: z13.literal(2),
+    backend: z13.literal("nccl"),
+    allocationMode: z13.literal("exclusive"),
+    workerImageDigest: z13.string().regex(/^sha256:[a-f0-9]{64}$/)
+  }).strict().optional(),
+  structuredOutputs: z13.object({
+    capability: z13.literal("work.structured-output.v1"),
     harnessRuntimeHash: HashSchema3,
     workHarnessHash: HashSchema3,
     schemaHash: HashSchema3,
     artifactHash: HashSchema3,
-    invalidDataRejected: z12.literal(true),
-    invalidBytesRejected: z12.literal(true)
+    invalidDataRejected: z13.literal(true),
+    invalidBytesRejected: z13.literal(true)
   }).strict().optional(),
-  placements: z12.array(z12.enum(["local", "remote", "colocated", "provider_native"])),
-  controls: z12.object({
-    cancel: z12.boolean(),
-    stopAfterGroup: z12.boolean(),
-    resumeFromCheckpoint: z12.boolean()
+  placements: z13.array(z13.enum(["local", "remote", "colocated", "provider_native"])),
+  controls: z13.object({
+    cancel: z13.boolean(),
+    stopAfterGroup: z13.boolean(),
+    resumeFromCheckpoint: z13.boolean()
   }).strict(),
-  estimates: z12.object({ schemaVersion: z12.literal("openpond.trainingEstimate.v1") }).strict().optional(),
-  limits: z12.object({
-    maximumSpendUsd: z12.number().nonnegative(),
-    maximumWallSeconds: z12.number().int().positive(),
-    maximumArtifactBytes: z12.number().int().positive()
+  estimates: z13.object({ schemaVersion: z13.literal("openpond.trainingEstimate.v1") }).strict().optional(),
+  limits: z13.object({
+    maximumSpendUsd: z13.number().nonnegative(),
+    maximumWallSeconds: z13.number().int().positive(),
+    maximumArtifactBytes: z13.number().int().positive()
   }).strict(),
   checkedAt: TimestampSchema,
   expiresAt: TimestampSchema
 }).strict();
-function headersRecord(headers) {
-  const result = {};
-  new Headers(headers).forEach((value, key) => {
-    result[key] = value;
-  });
-  return result;
-}
 function createTrainingClient(input) {
-  const fetchImpl = input.fetch ?? fetch;
-  const baseUrl = input.baseUrl.replace(/\/$/, "");
-  async function request(pathname, init, responseLimit = TRAINING_API_RESPONSE_MAX_BYTES) {
-    const readOnly = init?.method === void 0 || init.method.toUpperCase() === "GET";
-    const maximumAttempts = readOnly ? 3 : 1;
-    for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
-      let response;
-      try {
-        const configuredHeaders = typeof input.headers === "function" ? await input.headers() : input.headers ?? {};
-        response = await fetchImpl(`${baseUrl}${pathname}`, {
-          ...init,
-          headers: {
-            accept: OPENPOND_TRAINING_MEDIA_TYPE,
-            ...init?.body ? { "content-type": OPENPOND_TRAINING_MEDIA_TYPE } : {},
-            ...headersRecord(configuredHeaders),
-            ...headersRecord(init?.headers)
-          }
-        });
-      } catch (error2) {
-        if (attempt === maximumAttempts || init?.signal?.aborted || !trainingReadFailureIsRetryable(null, error2)) {
-          throw error2;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250 * 2 ** (attempt - 1)));
-        continue;
-      }
-      const body = await readBoundedJsonResponse(response, responseLimit, "Training API response");
-      if (response.ok) return body;
-      const error = trainingApiError(body, response.status);
-      if (attempt === maximumAttempts || !trainingReadFailureIsRetryable(response.status, error)) {
-        throw error;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 250 * 2 ** (attempt - 1)));
-    }
-    throw new OpenPondProtocolError(
-      "training_read_retry_exhausted",
-      "Training read retry loop exhausted without a response."
-    );
-  }
+  const request = createTrainingRequest(input);
   return {
     postTraining: createPostTrainingClient({ request }),
     ...createTrainingPreparationClient(request),
     ...createTrainingEstimateClient(request),
     ...createTrainingAcceptanceClient(request),
+    ...createTrainingHardwareClient(request),
     ...createTrainingHarnessSourceClient(request),
     ...createTrainingCandidateDecisionClient(request),
     async capabilities() {
@@ -1294,10 +1355,10 @@ function createTrainingClient(input) {
         parameters.set("modelProjectId", IdSchema3.parse(options.modelProjectId));
       }
       if (options.cursor) {
-        parameters.set("cursor", z12.string().trim().min(1).max(2e3).parse(options.cursor));
+        parameters.set("cursor", z13.string().trim().min(1).max(2e3).parse(options.cursor));
       }
       if (options.limit !== void 0) {
-        parameters.set("limit", String(z12.number().int().min(1).max(1e3).parse(options.limit)));
+        parameters.set("limit", String(z13.number().int().min(1).max(1e3).parse(options.limit)));
       }
       const query = parameters.size > 0 ? `?${parameters.toString()}` : "";
       return TrainingJobPageSchema.parse(await request(`/v1/training/jobs${query}`));
@@ -1347,7 +1408,7 @@ function createTrainingClient(input) {
       ), "job"));
     },
     async events(jobId) {
-      return z12.array(TrainingJobEventSchema).parse(
+      return z13.array(TrainingJobEventSchema).parse(
         unwrapObject(
           await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/events`),
           "events"
@@ -1363,11 +1424,11 @@ function createTrainingClient(input) {
       const id2 = IdSchema3.parse(jobId);
       const reference = ModelProjectImmutableRefSchema.parse(evaluation);
       const parameters = new URLSearchParams();
-      const cursor = options.cursor === void 0 ? void 0 : z12.string().regex(/^[1-9]\d*$/).parse(options.cursor);
-      const offset = cursor === void 0 ? 0 : z12.number().int().min(1).max(9999).parse(Number(cursor));
+      const cursor = options.cursor === void 0 ? void 0 : z13.string().regex(/^[1-9]\d*$/).parse(options.cursor);
+      const offset = cursor === void 0 ? 0 : z13.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(z12.number().int().min(1).max(100).parse(options.limit)));
+        parameters.set("limit", String(z13.number().int().min(1).max(100).parse(options.limit)));
       const query = parameters.size ? `?${parameters.toString()}` : "";
       return parseAndVerifyTrainingEvaluationTaskPage(
         await request(
@@ -1377,7 +1438,7 @@ function createTrainingClient(input) {
       );
     },
     async logs(jobId) {
-      return z12.array(TrainingJobLogSchema).max(1e5).parse(
+      return z13.array(TrainingJobLogSchema).max(1e5).parse(
         unwrapObject(
           await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/logs`),
           "logs"
@@ -1386,32 +1447,14 @@ function createTrainingClient(input) {
     }
   };
 }
-function trainingReadFailureIsRetryable(status, error) {
-  if (status !== null) {
-    return status === 408 || status === 429 || status >= 500;
-  }
-  if (error instanceof OpenPondTrainingApiError) return error.retryable;
-  if (error instanceof OpenPondProtocolError) {
-    return error.code === "invalid_error_response";
-  }
-  return error instanceof TypeError;
-}
 function unwrapObject(value, key) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return value;
   return key in value ? value[key] : value;
 }
-function trainingApiError(value, status) {
-  const parsed = TrainingApiErrorSchema.safeParse(value);
-  if (parsed.success) {
-    return new OpenPondTrainingApiError(status, parsed.data);
-  }
-  return new OpenPondProtocolError(
-    "invalid_error_response",
-    `Training request failed with HTTP ${status} and an invalid error envelope.`
-  );
-}
 
 export {
+  SftRecipeSchema,
+  ManagedSftRecipeSchema,
   TrainingAcceptanceGroupReferenceSchema,
   TrainingAcceptanceGroupSummarySchema,
   TrainingAcceptanceGroupPageSchema,
@@ -1477,11 +1520,9 @@ export {
   parseAndVerifyTrainingExecutionReceipt,
   assertTrainingQualificationReceipt,
   TrainingJobOutputsSchema,
-  TrainingApiErrorSchema,
-  OpenPondTrainingApiError,
   TrainingPolicyLoraCapabilitiesSchema,
   supportsTrainingPolicyLoraRank,
   TrainingCapabilitiesSchema,
   createTrainingClient
 };
-//# sourceMappingURL=chunk-EYMZQML2.js.map
+//# sourceMappingURL=chunk-GJRXJL6G.js.map