openpond-sdk 0.12.13 → 0.12.15

package/dist/chunk-GJRXJL6G.js

@@ -1,1528 +0,0 @@
-import {
-  createTrainingHardwareClient
-} from "./chunk-EZME7DV4.js";
-import {
-  createTrainingRequest
-} from "./chunk-GX6KMHW2.js";
-import {
-  TrainingHandoffOriginSchema,
-  createPostTrainingClient
-} from "./chunk-7BYLH47N.js";
-import {
-  validateHarnessPolicySourcePackage,
-  validateHarnessSourcePackage
-} from "./chunk-Q4TKI2MV.js";
-import {
-  ModelProjectBaseModelSchema,
-  ModelProjectImmutableRefSchema,
-  ModelProjectRecipeDocumentSchema,
-  ModelProjectVersionedRefSchema,
-  TrainingEstimateReviewSchema,
-  TrainingGpuCatalogSchema,
-  TrainingGpuSelectionSchema
-} from "./chunk-UOV2LEXS.js";
-import {
-  OpenPondProtocolError,
-  TRAINING_API_RESPONSE_MAX_BYTES,
-  TRAINING_INPUT_ARTIFACT_MAX_BYTES,
-  TRAINING_JOB_SUBMISSION_MAX_BYTES,
-  assertCanonicalPayloadSize,
-  canonicalSha256
-} from "./chunk-B3ZHJ2KK.js";
-import {
-  ImmutableReleaseRefSchema
-} from "./chunk-H3JZ3P5T.js";
-
-// src/training-supervised.ts
-import { z } from "zod";
-var Id = z.string().trim().min(1).max(240);
-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: Id2,
-  jobId: Id2,
-  plan: ModelProjectImmutableRefSchema,
-  baseline: ModelProjectImmutableRefSchema,
-  candidate: ModelProjectImmutableRefSchema,
-  state: AcceptanceGroupSnapshotSchema.shape.state,
-  updatedAt: z2.string().datetime()
-}).strict();
-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 = z2.object({
-  cursor: Id2.optional(),
-  limit: z2.number().int().min(1).max(100).default(25)
-}).strict();
-function createTrainingAcceptanceClient(request) {
-  const route = (target) => {
-    Id2.parse(target.teamId);
-    return `/v1/training/jobs/${encodeURIComponent(Id2.parse(target.jobId))}/acceptance-groups`;
-  };
-  return {
-    async acceptanceGroups(target, input = {}) {
-      const query = TrainingAcceptanceGroupQuerySchema.parse(input);
-      const params = new URLSearchParams({ limit: String(query.limit) });
-      if (query.cursor) params.set("cursor", query.cursor);
-      const page = TrainingAcceptanceGroupPageSchema.parse(await request(`${route(target)}?${params}`));
-      if (page.teamId !== target.teamId || page.jobId !== target.jobId || page.groups.length > query.limit || page.groups.some((group) => group.teamId !== target.teamId || group.jobId !== target.jobId || query.cursor && group.id <= query.cursor) || new Set(page.groups.map((group) => group.id)).size !== page.groups.length || page.nextCursor !== null && page.nextCursor !== page.groups.at(-1)?.id)
-        throw new OpenPondProtocolError("acceptance_group_scope_mismatch", "Acceptance groups do not match the requested workspace, job or cursor.");
-      return page;
-    },
-    async acceptanceGroup(target, groupId, expected) {
-      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(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;
-    }
-  };
-}
-
-// src/training.ts
-import { z as z13 } from "zod";
-
-// src/training-recovery.ts
-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: z3.number().int().positive(),
-  sourceInputManifestSha256: hash,
-  checkpointId: id,
-  adapterSha256: hash,
-  resumeSha256: hash,
-  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: z3.number().int().positive().max(21600),
-  maximumWallSeconds: z3.number().int().positive().max(21600)
-}).strict();
-var TrainingCheckpointRecoveryResourceApprovalSchema = ApprovalBodySchema.extend({
-  approvalHash: hash
-}).strict().superRefine((value, context) => {
-  if (value.maximumGpuSeconds > value.maximumWallSeconds)
-    context.addIssue({
-      code: "custom",
-      path: ["maximumGpuSeconds"],
-      message: "Recovery GPU duration exceeds its wall"
-    });
-});
-async function createTrainingCheckpointRecoveryResourceApproval(input) {
-  const body = ApprovalBodySchema.parse(input);
-  return TrainingCheckpointRecoveryResourceApprovalSchema.parse({
-    ...body,
-    approvalHash: await canonicalSha256(body)
-  });
-}
-var TrainingCheckpointRecoveryRequestSchema = z3.object({
-  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
-  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: 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({
-      code: "custom",
-      path: ["evaluationGpuType"],
-      message: "GPU substitution requires explicit evaluation-only recovery"
-    });
-  const a = value.resourceApproval;
-  if (a && (a.sourceJobVersion !== value.expectedVersion || a.checkpointId !== value.checkpointId || a.idempotencyKey !== value.idempotencyKey || a.maximumSpendUsd !== value.maximumSpendUsd || a.maximumWallSeconds !== value.maximumWallSeconds))
-    context.addIssue({
-      code: "custom",
-      path: ["resourceApproval"],
-      message: "Recovery resource approval does not match its request"
-    });
-});
-
-// src/training-physical-placement.ts
-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 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: z5.string().trim().min(1).max(191),
-  maximumSpendUsd: z5.number().finite().positive().max(1e6),
-  gpuSelection: TrainingGpuSelectionSchema.optional(),
-  physicalPlacement: TrainingPhysicalPlacementSchema.optional()
-}).strict();
-var TrainingPreparationPlanContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.trainingPreparationPlan.v1"),
-  id: Id3,
-  creatorUserId: Id3,
-  request: TrainingPreparationRequestSchema,
-  requestHash: Hash2,
-  source: z5.lazy(() => TrainingJobSourceSchema),
-  submissionHash: Hash2,
-  createdAt: z5.string().datetime({ offset: true })
-}).strict();
-var TrainingPreparationPlanSchema = TrainingPreparationPlanContentSchema.extend({
-  contentHash: Hash2
-}).strict();
-var TrainingPreparationReceiptSchema = z5.object({
-  schemaVersion: z5.literal("openpond.trainingPreparationReceipt.v1"),
-  plan: TrainingPreparationPlanSchema,
-  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({
-      code: "custom",
-      path: ["jobId"],
-      message: "Only submitted preparations identify a job."
-    });
-});
-var TrainingPreparationControlSchema = z5.object({
-  teamId: Id3,
-  planHash: Hash2,
-  expectedRevision: z5.number().int().positive(),
-  estimateReview: TrainingEstimateReviewSchema.optional()
-}).strict();
-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 = 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);
-  const { contentHash, ...plan } = receipt.plan;
-  if (await canonicalSha256(plan) !== contentHash || await canonicalSha256(plan.request) !== plan.requestHash || plan.source.modelProject.id !== plan.request.configuration.id || await canonicalSha256(plan.source.origin ?? null) !== await canonicalSha256(plan.request.origin ?? null)) {
-    throw new OpenPondProtocolError(
-      "training_preparation_mismatch",
-      "The prepared training inputs changed."
-    );
-  }
-  return receipt;
-}
-function createTrainingPreparationClient(request) {
-  async function read(value, teamId, id2) {
-    const receipt = await parseAndVerifyTrainingPreparationReceipt(value);
-    if (receipt.plan.request.teamId !== teamId || id2 && receipt.plan.id !== id2)
-      throw new OpenPondProtocolError(
-        "training_preparation_scope_mismatch",
-        "The training preparation belongs to a different workspace or request."
-      );
-    return receipt;
-  }
-  return {
-    /** Discover the authenticated user's retained preparations without creating jobs. */
-    async listPreparations(teamId, input = {}) {
-      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));
-      const page = TrainingPreparationPageSchema.parse(
-        await request(`/v1/training/preparations?${params}`)
-      );
-      if (page.teamId !== scope || page.items.length > query.limit || new Set(page.items.map((item) => item.plan.id)).size !== page.items.length || page.nextCursor !== null && (page.nextCursor !== page.items.at(-1)?.plan.id || page.nextCursor === query.afterId)) {
-        throw new OpenPondProtocolError(
-          "training_preparation_page_mismatch",
-          "The preparation page does not match its workspace or cursor."
-        );
-      }
-      const items = await Promise.all(
-        page.items.map(async (item) => {
-          const receipt = await read(item, scope);
-          if (query.projectId && receipt.plan.request.projectId !== query.projectId || query.state && receipt.state !== query.state) {
-            throw new OpenPondProtocolError(
-              "training_preparation_page_mismatch",
-              "A preparation does not match the requested Project or state."
-            );
-          }
-          return receipt;
-        })
-      );
-      return { ...page, items };
-    },
-    async prepareRun(input) {
-      const parsed = TrainingPreparationRequestSchema.parse(input);
-      const receipt = await read(
-        await request("/v1/training/preparations", {
-          method: "POST",
-          body: JSON.stringify(parsed)
-        }),
-        parsed.teamId
-      );
-      if (receipt.plan.requestHash !== await canonicalSha256(parsed))
-        throw new OpenPondProtocolError(
-          "training_preparation_request_mismatch",
-          "The preparation does not match the requested run."
-        );
-      return receipt;
-    },
-    async getPreparation(teamId, id2) {
-      return read(
-        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(Id3.parse(id2))}/start`, {
-          method: "POST",
-          body: JSON.stringify(parsed)
-        }),
-        parsed.teamId,
-        id2
-      );
-      if (receipt.plan.contentHash !== parsed.planHash || receipt.state !== "submitted")
-        throw new OpenPondProtocolError(
-          "training_preparation_start_mismatch",
-          "The submitted run does not match the approved preparation."
-        );
-      return receipt;
-    },
-    async cancelPreparation(id2, input) {
-      const parsed = TrainingPreparationControlSchema.parse(input);
-      const receipt = await read(
-        await request(`/v1/training/preparations/${encodeURIComponent(Id3.parse(id2))}/cancel`, {
-          method: "POST",
-          body: JSON.stringify(parsed)
-        }),
-        parsed.teamId,
-        id2
-      );
-      if (receipt.plan.contentHash !== parsed.planHash || receipt.state !== "cancelled")
-        throw new OpenPondProtocolError(
-          "training_preparation_cancel_mismatch",
-          "The preparation cancellation could not be verified."
-        );
-      return receipt;
-    }
-  };
-}
-
-// src/training-estimates.ts
-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(),
-  z6.object({ kind: z6.literal("submission"), submission: z6.lazy(() => TrainingJobSubmissionSchema) }).strict()
-]);
-var TrainingEstimateRequestSchema = z6.object({
-  schemaVersion: z6.literal("openpond.trainingEstimateRequest.v1"),
-  teamId: Id4,
-  source: TrainingEstimateSourceSchema,
-  gpuSelection: TrainingGpuSelectionSchema.optional()
-}).strict();
-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",
-    "optimization",
-    "checkpointing",
-    "backbone_materialization",
-    "final_evaluation",
-    "publication",
-    "cleanup",
-    "retention"
-  ]),
-  resource: z6.enum(["gpu", "cpu", "judge", "storage", "network"]),
-  expectedUsd: NonNegative.nullable(),
-  expectedSeconds: NonNegative.nullable(),
-  planningRangeUsd: PlanningRange.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 {
-    kind: source.kind,
-    id: source.submission.idempotencyKey,
-    contentHash: source.submission.contentHash,
-    revision: null
-  };
-  if (source.kind === "preparation") return {
-    kind: source.kind,
-    id: source.id,
-    contentHash: source.planHash,
-    revision: source.expectedRevision
-  };
-  return { kind: source.kind, id: source.id, contentHash: source.expectedEtag, revision: source.expectedRevision };
-}
-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: z6.enum(["available", "partial", "insufficient_evidence"]),
-  currency: z6.literal("USD"),
-  createdAt: Timestamp,
-  expiresAt: Timestamp,
-  estimatorVersion: Id4,
-  runtimeVersion: Id4,
-  pricing: z6.object({ version: Id4, quoteExpiresAt: Timestamp.nullable() }).strict(),
-  gpu: z6.object({
-    requested: TrainingGpuSelectionSchema,
-    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: z6.enum(["available", "limited", "unavailable", "unknown"])
-  }).strict(),
-  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: z6.object({
-    expectedUsd: NonNegative.nullable(),
-    planningRangeUsd: PlanningRange.nullable(),
-    knownMinimumUsd: NonNegative,
-    recommendedMaximumUsd: NonNegative.nullable(),
-    minimumCleanupReserveUsd: NonNegative.nullable(),
-    components: z6.array(TrainingEstimateComponentSchema).max(50)
-  }).strict(),
-  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: 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) {
-    context.addIssue({ code: "custom", path: ["review"], message: "Estimate review identity differs from the estimate" });
-  }
-  if (Date.parse(estimate.expiresAt) <= Date.parse(estimate.createdAt)) {
-    context.addIssue({ code: "custom", path: ["expiresAt"], message: "Estimate must expire after its creation" });
-  }
-  if (estimate.status === "available" && (estimate.cost.expectedUsd === null || estimate.executionSeconds.expected === null || estimate.unknowns.length > 0)) {
-    context.addIssue({ code: "custom", path: ["status"], message: "An available estimate requires complete cost and duration coverage" });
-  }
-  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 {
-    async estimate(input) {
-      const parsed = TrainingEstimateRequestSchema.parse(input);
-      if (parsed.source.kind === "submission") await parseAndVerifyTrainingJobSubmission(parsed.source.submission);
-      const result = TrainingEstimateSchema.parse(await request("/v1/training/estimates", {
-        method: "POST",
-        body: JSON.stringify(parsed)
-      }));
-      if (result.teamId !== parsed.teamId || result.requestHash !== await canonicalSha256(parsed) || await canonicalSha256(result.source) !== await canonicalSha256(trainingEstimateSourceIdentity(parsed.source)) || parsed.gpuSelection && await canonicalSha256(result.gpu.requested) !== await canonicalSha256(parsed.gpuSelection)) {
-        throw new OpenPondProtocolError("training_estimate_scope_mismatch", "The estimate does not match the requested workspace and exact configuration.");
-      }
-      return result;
-    }
-  };
-}
-
-// src/training-queue.ts
-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: z7.object({
-    revision: z7.number().int().nonnegative(),
-    estimatedStartAt: Timestamp2,
-    expiresAt: Timestamp2,
-    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))
-    context.addIssue({ code: "custom", path: ["estimate"], message: "An expired queue forecast must be returned as unavailable" });
-});
-
-// src/training-harness-sources.ts
-import { z as z8 } from "zod";
-var TrainingHarnessSourcePublicationSchema = z8.object({
-  schemaVersion: z8.literal("openpond.trainingHarnessSourcePublication.v1"),
-  harnessRelease: ImmutableReleaseRefSchema,
-  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) => {
-    const ref = ImmutableReleaseRefSchema.parse(reference);
-    return `/v1/training/harness-sources/${encodeURIComponent(ref.id)}/${ref.contentHash}`;
-  };
-  return {
-    async publishHarnessSource(value) {
-      assertCanonicalPayloadSize(value, TRAINING_INPUT_ARTIFACT_MAX_BYTES, "Training Harness source");
-      const source = validateSource(value);
-      const portability = source.agentSnapshot.portability;
-      if (!portability.portable || portability.blockers.length || portability.localOnlyAssetRefs.length || portability.hostPrivateAssetRefs.length || source.schemaVersion === "openpond.harnessSourcePackage.v1" && source.harnessRelease.files.some((file) => file.visibility !== "policy")) {
-        throw new Error("Hosted training Harness publication requires portable, policy-visible source.");
-      }
-      const result = TrainingHarnessSourcePublicationSchema.parse(await request(route({ id: source.harnessRelease.id, contentHash: source.harnessRelease.contentHash }), { method: "PUT", body: JSON.stringify(source) }));
-      if (result.harnessRelease.id !== source.harnessRelease.id || result.harnessRelease.contentHash !== source.harnessRelease.contentHash || result.sourcePackageHash !== source.contentHash) {
-        throw new Error("Published Harness source differs from the selected immutable package.");
-      }
-      return result;
-    },
-    async getHarnessSource(reference) {
-      const value = await request(route(reference), void 0, TRAINING_INPUT_ARTIFACT_MAX_BYTES);
-      assertCanonicalPayloadSize(value, TRAINING_INPUT_ARTIFACT_MAX_BYTES, "Training Harness source");
-      return validateSource(value, reference);
-    }
-  };
-}
-function validateSource(value, reference) {
-  return typeof value === "object" && value !== null && Reflect.get(value, "schemaVersion") === "openpond.harnessPolicySourcePackage.v1" ? validateHarnessPolicySourcePackage(value, reference) : validateHarnessSourcePackage(value, reference);
-}
-
-// src/training-candidate-decisions.ts
-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: z9.enum(["accepted", "rejected"]),
-  reason: z9.string().trim().min(1).max(5e3),
-  idempotencyKey: IdSchema,
-  expectedDecision: ModelProjectImmutableRefSchema.nullable()
-}).strict())();
-var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z9.object({
-  schemaVersion: z9.literal("openpond.trainingCandidateDecision.v1"),
-  id: IdSchema,
-  request: TrainingCandidateDecisionRequestSchema,
-  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)) {
-    context.addIssue({ code: "custom", path: ["revision"], message: "A first decision has no predecessor; later decisions must reference the prior decision." });
-  }
-  if (value.request.expectedDecision?.id === value.id) {
-    context.addIssue({ code: "custom", path: ["request", "expectedDecision"], message: "A decision cannot supersede itself." });
-  }
-}))();
-async function trainingCandidateDecisionHash(value) {
-  const { contentHash: _contentHash, ...content } = value;
-  return canonicalSha256(content);
-}
-async function parseAndVerifyTrainingCandidateDecision(value, expected) {
-  assertCanonicalPayloadSize(value, 32768, "Training candidate decision");
-  const parsed = TrainingCandidateDecisionSchema.parse(value);
-  if (parsed.contentHash !== await trainingCandidateDecisionHash(parsed)) {
-    throw new OpenPondProtocolError("content_hash_mismatch", "Training candidate decision content hash does not match.");
-  }
-  if (parsed.request.teamId !== expected.teamId || parsed.request.jobId !== expected.jobId || parsed.request.artifact.id !== expected.artifact.id || parsed.request.artifact.contentHash !== expected.artifact.contentHash) {
-    throw new OpenPondProtocolError("candidate_decision_identity_mismatch", "Training candidate decision belongs to a different team, Job or artifact.");
-  }
-  if (expected.request && await canonicalSha256(parsed.request) !== await canonicalSha256(TrainingCandidateDecisionRequestSchema.parse(expected.request))) {
-    throw new OpenPondProtocolError("candidate_decision_request_mismatch", "Training candidate decision does not match the submitted review.");
-  }
-  return parsed;
-}
-function createTrainingCandidateDecisionClient(request) {
-  function route(target) {
-    return `/v1/training/jobs/${encodeURIComponent(IdSchema.parse(target.jobId))}/candidates/${encodeURIComponent(ModelProjectImmutableRefSchema.parse(target.artifact).id)}/decision`;
-  }
-  return {
-    async candidateDecision(target, options = {}) {
-      IdSchema.parse(target.teamId);
-      const reference = options.decision ? ModelProjectImmutableRefSchema.parse(options.decision) : void 0;
-      const query = reference ? `?decisionId=${encodeURIComponent(reference.id)}` : "";
-      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)) {
-        throw new OpenPondProtocolError("candidate_decision_identity_mismatch", "Training candidate decision does not match the requested history entry.");
-      }
-      return decision;
-    },
-    async recordCandidateDecision(input) {
-      const parsed = TrainingCandidateDecisionRequestSchema.parse(input);
-      const response = await request(route(parsed), { method: "POST", body: JSON.stringify(parsed) });
-      return parseAndVerifyTrainingCandidateDecision(response, { ...parsed, request: parsed });
-    }
-  };
-}
-
-// src/training-evaluation-results.ts
-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: z10.object({
-    instruction: z10.string().max(1e6),
-    context: z10.record(z10.string(), z10.unknown())
-  }).strict(),
-  output: z10.string().max(1e6),
-  outputSha256: HashSchema2,
-  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__ */ (() => z10.object({
-  schemaVersion: z10.literal("openpond.trainingEvaluationTaskPage.v1"),
-  jobId: IdSchema2,
-  teamId: IdSchema2,
-  evaluation: ModelProjectImmutableRefSchema,
-  kind: z10.enum(["baseline", "candidate"]),
-  policyVersion: z10.number().int().nonnegative(),
-  taskset: ModelProjectVersionedRefSchema,
-  panelSha256: HashSchema2,
-  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;
-  const expectedCursor = end < page.total ? String(end) : null;
-  if (end > page.total || page.nextCursor !== expectedCursor) {
-    context.addIssue({ code: "custom", path: ["nextCursor"], message: "Evaluation pagination must cover consecutive task positions." });
-  }
-  if (new Set(page.tasks.map((task) => task.taskId)).size !== page.tasks.length) {
-    context.addIssue({ code: "custom", path: ["tasks"], message: "Evaluation task identities must be unique." });
-  }
-}))();
-async function trainingEvaluationTaskPageHash(value) {
-  const { contentHash: _contentHash, ...content } = value;
-  return canonicalSha256(content);
-}
-async function parseAndVerifyTrainingEvaluationTaskPage(value, expected) {
-  assertCanonicalPayloadSize(value, TRAINING_API_RESPONSE_MAX_BYTES, "Training evaluation task page");
-  const page = TrainingEvaluationTaskPageSchema.parse(value);
-  const reference = ModelProjectImmutableRefSchema.parse(expected.evaluation);
-  if (page.jobId !== IdSchema2.parse(expected.jobId) || page.evaluation.id !== reference.id || page.evaluation.contentHash !== reference.contentHash || page.offset !== (expected.offset ?? 0) || expected.teamId !== void 0 && page.teamId !== IdSchema2.parse(expected.teamId)) {
-    throw new OpenPondProtocolError("evaluation_page_identity_mismatch", "Evaluation results differ from the requested Job, evaluation, or page.");
-  }
-  if (await trainingEvaluationTaskPageHash(page) !== page.contentHash) {
-    throw new OpenPondProtocolError("evaluation_page_hash_mismatch", "Evaluation task page content hash did not match.");
-  }
-  for (const task of page.tasks) {
-    if (await canonicalSha256(task.output) !== task.outputSha256) {
-      throw new OpenPondProtocolError("evaluation_output_hash_mismatch", "A retained evaluation output hash did not match.");
-    }
-  }
-  return page;
-}
-
-// src/training-grading-plan.ts
-import { z as z11 } from "zod";
-import { compileBoundGraders, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
-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: z11.array(RewardReleaseSchema).min(1).max(100)
-}).strict();
-async function deterministicTrainingRewardSource(input) {
-  const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
-  const graders = GradersSchema.parse(execution ? compileBoundGraders(execution.binding, execution.rewards) : input.graders);
-  if (new Set(graders.map((grader) => grader.id)).size !== graders.length) {
-    throw new Error("Training grader identities must be unique.");
-  }
-  const hash2 = await canonicalSha256({ schemaVersion: "openpond.trainingGraderSet.v1", graders });
-  return {
-    kind: "deterministic",
-    grader: { id: `training-graders-${hash2.slice(0, 32)}`, contentHash: hash2 },
-    composer: execution ? { id: execution.binding.id, contentHash: execution.binding.contentHash } : null
-  };
-}
-
-// src/training-evaluation-source.ts
-import { z as z12 } from "zod";
-var TRAINING_EVALUATION_SOURCE_PATH = "evaluation-source.json";
-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 = z12.object({
-  schemaVersion: z12.literal("openpond.trainingEvaluationSource.v1"),
-  taskset: ModelProjectVersionedRefSchema,
-  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();
-  source.tasks.forEach((task, index) => {
-    if (task.split === "train") context.addIssue({ code: "custom", path: ["tasks", index, "split"], message: "Evaluation sources require held-out tasks." });
-    if (ids.has(task.id)) context.addIssue({ code: "custom", path: ["tasks", index, "id"], message: "Evaluation task identities must be unique." });
-    ids.add(task.id);
-  });
-});
-function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
-  const training = 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) {
-    if (task.split !== "train") throw new Error("The training population contains a held-out task.");
-    if (trainIds.has(task.id)) throw new Error("Training task identities must be unique.");
-    trainIds.add(task.id);
-    trainFamilies.add(task.clusterKey);
-  }
-  const evaluationIds = /* @__PURE__ */ new Set();
-  for (const task of evaluation) {
-    if (task.split === "train") throw new Error("The evaluation population contains a training task.");
-    if (evaluationIds.has(task.id)) throw new Error("Evaluation task identities must be unique.");
-    if (trainIds.has(task.id) || trainFamilies.has(task.clusterKey)) {
-      throw new Error("Training and evaluation tasks or families overlap.");
-    }
-    evaluationIds.add(task.id);
-  }
-}
-async function trainingEvaluationSourceRef(input) {
-  const source = TrainingEvaluationSourceSchema.parse(input);
-  const hash2 = await canonicalSha256(source);
-  return { taskset: source.taskset, dataset: { id: `training-evaluation-${hash2.slice(0, 32)}`, contentHash: hash2 } };
-}
-
-// src/training.ts
-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: z13.unknown(),
-  contentHash: HashSchema3
-}).strict();
-var TrainingInputArtifactSchema = z13.object({
-  schemaVersion: z13.literal("openpond.trainingInputArtifact.v2"),
-  kind: z13.enum(["portable_training_bundle", "reward_model_dataset"]),
-  sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z13.string().trim().min(1).max(2e3),
-  contentHash: HashSchema3,
-  sizeBytes: z13.number().int().positive(),
-  createdAt: TimestampSchema
-}).strict();
-async function trainingInputArtifactUploadHash(upload) {
-  const { contentHash: _contentHash, ...content } = upload;
-  return canonicalSha256(content);
-}
-async function parseAndVerifyTrainingInputArtifactUpload(value) {
-  assertCanonicalPayloadSize(value, TRAINING_INPUT_ARTIFACT_MAX_BYTES, "Training input artifact");
-  const parsed = TrainingInputArtifactUploadSchema.parse(value);
-  const expectedHash = await trainingInputArtifactUploadHash(parsed);
-  if (parsed.contentHash !== expectedHash) {
-    throw new OpenPondProtocolError(
-      "content_hash_mismatch",
-      `Training input artifact contentHash ${parsed.contentHash} does not match ${expectedHash}.`
-    );
-  }
-  return parsed;
-}
-var TrainingJobKindSchema = z13.enum(["reward_model_train", "policy_optimize"]);
-var TrainingJobStateSchema = z13.enum([
-  "queued",
-  "admitting",
-  "provisioning",
-  "running",
-  "stopping",
-  "cancelling",
-  "succeeded",
-  "failed",
-  "cancelled"
-]);
-var TrainingCapabilityRequirementSchema = z13.object({
-  id: IdSchema3,
-  version: z13.string().trim().min(1).max(200).nullable().default(null),
-  required: z13.boolean().default(true)
-}).strict();
-var TrainingJobSourceSchema = z13.object({
-  origin: TrainingHandoffOriginSchema.optional(),
-  modelProject: z13.object({
-    id: IdSchema3,
-    portableProjectId: IdSchema3,
-    revision: z13.number().int().positive(),
-    contentHash: HashSchema3
-  }).strict(),
-  harnessRunManifest: ModelProjectImmutableRefSchema,
-  harnessRelease: ModelProjectImmutableRefSchema,
-  taskset: ModelProjectVersionedRefSchema,
-  tasksetRelease: ModelProjectImmutableRefSchema,
-  evaluation: z13.object({
-    taskset: ModelProjectVersionedRefSchema,
-    dataset: ModelProjectImmutableRefSchema
-  }).strict().nullable().optional(),
-  dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z13.array(ModelProjectImmutableRefSchema).max(1e4)
-}).strict();
-var RewardModelTrainingRequestSchema = z13.object({
-  kind: z13.literal("reward_model_train"),
-  baseModel: ModelProjectBaseModelSchema,
-  preferenceDatasetRelease: ModelProjectImmutableRefSchema,
-  processorRelease: ModelProjectImmutableRefSchema,
-  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 = z13.object({
-  kind: z13.literal("deterministic"),
-  grader: ModelProjectImmutableRefSchema,
-  composer: ModelProjectImmutableRefSchema.nullable().default(null)
-}).strict();
-var LearnedRewardSourceSchema = z13.object({
-  kind: z13.literal("learned_reward"),
-  rewardModelVersion: ModelProjectImmutableRefSchema,
-  qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z13.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z13.object({
-    artifactRef: z13.string().trim().min(1).max(2e3),
-    contentHash: HashSchema3,
-    executionReceipt: ModelProjectImmutableRefSchema
-  }).strict(),
-  processorRelease: ModelProjectImmutableRefSchema,
-  rewardComposerRelease: ModelProjectImmutableRefSchema
-}).strict();
-var TrainingQualificationBaseModelSchema = ModelProjectBaseModelSchema.extend({
-  revision: z13.string().regex(/^[a-f0-9]{40,64}$/),
-  tokenizerRevision: z13.string().regex(/^[a-f0-9]{40,64}$/),
-  chatTemplateHash: HashSchema3
-}).strict();
-var PolicyOptimizationRequestSchema = z13.object({
-  kind: z13.literal("policy_optimize"),
-  /** Collect and grade one original-learner group without optimizer work. */
-  executionMode: z13.literal("qualification").optional(),
-  baseModel: ModelProjectBaseModelSchema,
-  recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z13.discriminatedUnion("kind", [
-    DeterministicRewardSourceSchema,
-    LearnedRewardSourceSchema
-  ]),
-  resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
-}).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 = z13.object({
-  approvalHash: HashSchema3,
-  approvedAt: TimestampSchema,
-  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 = 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: z13.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z13.enum(["fast", "balanced", "economical"]),
-  gpuSelection: TrainingGpuSelectionSchema.optional(),
-  physicalPlacement: TrainingPhysicalPlacementSchema.optional(),
-  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." });
-  }
-  if (submission.job.kind === "policy_optimize" && submission.job.executionMode === "qualification") {
-    const job = submission.job;
-    if (!TrainingQualificationBaseModelSchema.safeParse(job.baseModel).success) {
-      context.addIssue({ code: "custom", path: ["job", "baseModel"], message: "Qualification requires immutable model and tokenizer revisions and a SHA-256 chat-template pin." });
-    }
-    if (job.resumeFrom || job.recipe.continuation !== void 0 || job.rewardSource.kind !== "deterministic" || job.recipe.method !== "grpo") {
-      context.addIssue({
-        code: "custom",
-        path: ["job"],
-        message: "Qualification requires the original GRPO learner, deterministic reward, and no resume or continuation."
-      });
-    }
-    if (!submission.requestedCapabilities.some((requirement) => requirement.required && requirement.id === "managed_rl.policy.qualification" && requirement.version === "1")) {
-      context.addIssue({
-        code: "custom",
-        path: ["requestedCapabilities"],
-        message: "Qualification must require managed_rl.policy.qualification@1."
-      });
-    }
-  }
-  if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
-    context.addIssue({
-      code: "custom",
-      path: ["approval", "maximumSpendUsd"],
-      message: "Approved spend must equal the immutable Job budget."
-    });
-  }
-});
-async function trainingJobSubmissionHash(submission) {
-  const { contentHash: _contentHash, ...content } = submission;
-  return canonicalSha256(content);
-}
-async function parseAndVerifyTrainingJobSubmission(value) {
-  assertCanonicalPayloadSize(value, TRAINING_JOB_SUBMISSION_MAX_BYTES, "Training Job submission");
-  const parsed = TrainingJobSubmissionSchema.parse(value);
-  const expectedHash = await trainingJobSubmissionHash(parsed);
-  if (parsed.contentHash !== expectedHash) {
-    throw new OpenPondProtocolError(
-      "content_hash_mismatch",
-      `Training Job contentHash ${parsed.contentHash} does not match ${expectedHash}.`
-    );
-  }
-  return parsed;
-}
-var TrainingJobRecoverySchema = z13.object({
-  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
-  mode: z13.literal("evaluation_only").optional(),
-  trainingWorkloadComplete: z13.boolean().optional(),
-  sourceJobId: IdSchema3,
-  checkpointId: IdSchema3,
-  policyVersion: z13.number().int().positive(),
-  completedGroups: z13.number().int().positive(),
-  optimizerMode: z13.literal("continue")
-}).strict();
-var TrainingJobSchema = z13.object({
-  schemaVersion: z13.literal("openpond.trainingJob.v2"),
-  id: IdSchema3,
-  teamId: IdSchema3,
-  kind: TrainingJobKindSchema,
-  executionMode: z13.literal("qualification").optional(),
-  recovery: TrainingJobRecoverySchema.optional(),
-  modelProjectId: IdSchema3,
-  portableProjectId: IdSchema3,
-  sourceProjectRevision: z13.number().int().positive(),
-  submissionHash: HashSchema3,
-  state: TrainingJobStateSchema,
-  queue: TrainingQueueStatusSchema.optional(),
-  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: z13.number().nonnegative(),
-  terminalReason: z13.string().trim().min(1).max(5e3).nullable(),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema,
-  completedAt: TimestampSchema.nullable()
-}).strict();
-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 = z13.object({
-  schemaVersion: z13.literal("openpond.trainingJobEvent.v2"),
-  id: IdSchema3,
-  jobId: IdSchema3,
-  sequence: z13.number().int().nonnegative(),
-  type: IdSchema3,
-  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 = z13.object({
-  schemaVersion: z13.literal("openpond.trainingJobLog.v2"),
-  jobId: IdSchema3,
-  sequence: z13.number().int().nonnegative(),
-  level: z13.enum(["debug", "info", "warning", "error"]),
-  message: z13.string().max(2e4),
-  createdAt: TimestampSchema
-}).strict();
-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: z13.enum(["checkpoint", "adapter", "scorer", "metrics", "evaluation", "trace", "receipt"]),
-  artifactRef: z13.string().trim().min(1).max(2e3),
-  contentHash: HashSchema3,
-  sizeBytes: z13.number().int().nonnegative(),
-  metadata: z13.record(z13.string(), z13.unknown()).default({}),
-  createdAt: TimestampSchema
-}).strict();
-var TrainingQualificationEvidenceSchema = z13.object({
-  schemaVersion: z13.literal("openpond.trainingQualificationEvidence.v1"),
-  baseModel: TrainingQualificationBaseModelSchema,
-  group: ModelProjectImmutableRefSchema,
-  rolloutReceipts: z13.array(ModelProjectImmutableRefSchema).min(1).max(1e3),
-  rewardEvidenceHash: HashSchema3,
-  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 = z13.object({
-  schemaVersion: z13.literal("openpond.trainingExecutionReceipt.v2"),
-  id: IdSchema3,
-  teamId: IdSchema3,
-  jobId: IdSchema3,
-  submissionHash: HashSchema3,
-  manifestHash: HashSchema3,
-  recipeHash: HashSchema3,
-  capabilityHash: HashSchema3,
-  runtimeRelease: ModelProjectImmutableRefSchema,
-  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: z13.string().trim().min(1).max(1e4).nullable()
-}).strict();
-async function trainingExecutionReceiptHash(receipt) {
-  return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
-}
-async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
-  const receipt = TrainingExecutionReceiptSchema.parse(value);
-  const expectedId = IdSchema3.parse(expected.id);
-  const expectedHash = HashSchema3.parse(expected.contentHash);
-  const actualHash = await trainingExecutionReceiptHash(receipt);
-  if (receipt.id !== expectedId || actualHash !== expectedHash) {
-    throw new OpenPondProtocolError(
-      "execution_receipt_mismatch",
-      "The execution receipt identity or canonical content hash did not match."
-    );
-  }
-  if (expected.teamId !== void 0 && receipt.teamId !== IdSchema3.parse(expected.teamId)) {
-    throw new OpenPondProtocolError(
-      "execution_receipt_team_mismatch",
-      "The execution receipt belongs to a different team."
-    );
-  }
-  if (expected.jobId !== void 0 && receipt.jobId !== IdSchema3.parse(expected.jobId)) {
-    throw new OpenPondProtocolError(
-      "execution_receipt_job_mismatch",
-      "The execution receipt belongs to a different Training Job."
-    );
-  }
-  if ((expected.requireCleanup ?? true) && !receipt.cleanupComplete) {
-    throw new OpenPondProtocolError(
-      "execution_cleanup_incomplete",
-      "The execution receipt does not attest complete terminal cleanup."
-    );
-  }
-  if (expected.qualificationSubmission) {
-    const submission = await parseAndVerifyTrainingJobSubmission(expected.qualificationSubmission);
-    if (submission.job.kind !== "policy_optimize" || submission.job.executionMode !== "qualification") {
-      throw new OpenPondProtocolError("qualification_submission_required", "Expected an immutable qualification submission.");
-    }
-    await assertTrainingQualificationReceipt(receipt, { submissionHash: submission.contentHash, baseModel: submission.job.baseModel, outputs: expected.outputs });
-  }
-  return receipt;
-}
-async function assertTrainingQualificationReceipt(receipt, expected) {
-  const evidence = TrainingQualificationEvidenceSchema.parse(receipt.qualification);
-  if (receipt.submissionHash !== expected.submissionHash || !receipt.cleanupComplete) {
-    throw new OpenPondProtocolError("qualification_receipt_mismatch", "Qualification must attest the expected submission and complete cleanup.");
-  }
-  if (expected.baseModel && await canonicalSha256(evidence.baseModel) !== await canonicalSha256(expected.baseModel)) {
-    throw new OpenPondProtocolError("qualification_learner_mismatch", "Qualification used a different original learner or tokenizer.");
-  }
-  if (expected.outputs?.some((output) => ["checkpoint", "adapter", "scorer"].includes(output.kind))) {
-    throw new OpenPondProtocolError("qualification_updated_artifact", "Qualification must not publish trained artifacts or checkpoints.");
-  }
-}
-var TrainingJobOutputsSchema = z13.object({
-  schemaVersion: z13.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z13.array(TrainingJobOutputSchema).max(1e4),
-  receipt: TrainingExecutionReceiptSchema.nullable()
-}).strict();
-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))
-    context.addIssue({ code: "custom", path: ["supportedRanks"], message: "Supported ranks must be unique and fit the physical adapter envelope." });
-  if (value.supportedRanks.length && !value.qualification)
-    context.addIssue({ code: "custom", path: ["qualification"], message: "Advertised ranks require immutable image qualification evidence." });
-});
-function supportsTrainingPolicyLoraRank(capabilities, rank, continuation) {
-  if (!capabilities.supportedRanks.includes(rank)) return false;
-  if (!continuation) return true;
-  return continuation.mode === "residual_append" ? continuation.parentEnabledRank + rank <= capabilities.envelopeRank : continuation.parentEnabledRank === rank;
-}
-var TrainingCapabilitiesSchema = z13.object({
-  schemaVersion: z13.literal("openpond.trainingCapabilities.v2"),
-  capabilityHash: HashSchema3,
-  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(),
-  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: z13.literal(true),
-    invalidBytesRejected: z13.literal(true)
-  }).strict().optional(),
-  placements: z13.array(z13.enum(["local", "remote", "colocated", "provider_native"])),
-  controls: z13.object({
-    cancel: z13.boolean(),
-    stopAfterGroup: z13.boolean(),
-    resumeFromCheckpoint: z13.boolean()
-  }).strict(),
-  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 createTrainingClient(input) {
-  const request = createTrainingRequest(input);
-  return {
-    postTraining: createPostTrainingClient({ request }),
-    ...createTrainingPreparationClient(request),
-    ...createTrainingEstimateClient(request),
-    ...createTrainingAcceptanceClient(request),
-    ...createTrainingHardwareClient(request),
-    ...createTrainingHarnessSourceClient(request),
-    ...createTrainingCandidateDecisionClient(request),
-    async capabilities() {
-      return TrainingCapabilitiesSchema.parse(
-        unwrapObject(await request("/v1/training/capabilities"), "capabilities")
-      );
-    },
-    async gpuCatalog() {
-      return TrainingGpuCatalogSchema.parse(unwrapObject(await request("/v1/training/gpu-catalog"), "catalog"));
-    },
-    async stageArtifact(upload) {
-      const parsed = await parseAndVerifyTrainingInputArtifactUpload(upload);
-      return TrainingInputArtifactSchema.parse(
-        unwrapObject(
-          await request("/v1/training/artifacts", {
-            method: "POST",
-            body: JSON.stringify(parsed)
-          }),
-          "artifact"
-        )
-      );
-    },
-    async createJob(submission) {
-      const parsed = await parseAndVerifyTrainingJobSubmission(submission);
-      return TrainingJobSchema.parse(
-        unwrapObject(
-          await request("/v1/training/jobs", {
-            method: "POST",
-            body: JSON.stringify(parsed)
-          }),
-          "job"
-        )
-      );
-    },
-    async listJobs(options = {}) {
-      const parameters = new URLSearchParams();
-      if (options.modelProjectId) {
-        parameters.set("modelProjectId", IdSchema3.parse(options.modelProjectId));
-      }
-      if (options.cursor) {
-        parameters.set("cursor", z13.string().trim().min(1).max(2e3).parse(options.cursor));
-      }
-      if (options.limit !== void 0) {
-        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}`));
-    },
-    async getJob(jobId) {
-      return TrainingJobSchema.parse(
-        unwrapObject(
-          await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}`),
-          "job"
-        )
-      );
-    },
-    async cancelJob(jobId, expectedVersion) {
-      const control = TrainingJobControlRequestSchema.parse({ expectedVersion });
-      return TrainingJobSchema.parse(
-        unwrapObject(
-          await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/cancel`, {
-            method: "POST",
-            body: JSON.stringify(control)
-          }),
-          "job"
-        )
-      );
-    },
-    async stopAfterGroup(jobId, expectedVersion) {
-      const control = TrainingJobControlRequestSchema.parse({ expectedVersion });
-      return TrainingJobSchema.parse(
-        unwrapObject(
-          await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/stop-after-group`,
-            { method: "POST", body: JSON.stringify(control) }
-          ),
-          "job"
-        )
-      );
-    },
-    async recoverCheckpoint(jobId, input2) {
-      const recovery = TrainingCheckpointRecoveryRequestSchema.parse(input2);
-      if (recovery.resourceApproval) {
-        const { approvalHash, ...body } = recovery.resourceApproval;
-        if (body.sourceJobId !== jobId || await canonicalSha256(body) !== approvalHash)
-          throw new OpenPondProtocolError("content_hash_mismatch", "Recovery resource approval does not bind this source request.");
-      }
-      return TrainingJobSchema.parse(unwrapObject(await request(
-        `/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/recover`,
-        { method: "POST", body: JSON.stringify(recovery) }
-      ), "job"));
-    },
-    async events(jobId) {
-      return z13.array(TrainingJobEventSchema).parse(
-        unwrapObject(
-          await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/events`),
-          "events"
-        )
-      );
-    },
-    async outputs(jobId) {
-      return TrainingJobOutputsSchema.parse(
-        await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/outputs`)
-      );
-    },
-    async evaluationTasks(jobId, evaluation, options = {}) {
-      const id2 = IdSchema3.parse(jobId);
-      const reference = ModelProjectImmutableRefSchema.parse(evaluation);
-      const parameters = new URLSearchParams();
-      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(z13.number().int().min(1).max(100).parse(options.limit)));
-      const query = parameters.size ? `?${parameters.toString()}` : "";
-      return parseAndVerifyTrainingEvaluationTaskPage(
-        await request(
-          `/v1/training/jobs/${encodeURIComponent(id2)}/evaluations/${encodeURIComponent(reference.id)}/tasks${query}`
-        ),
-        { jobId: id2, evaluation: reference, offset }
-      );
-    },
-    async logs(jobId) {
-      return z13.array(TrainingJobLogSchema).max(1e5).parse(
-        unwrapObject(
-          await request(`/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/logs`),
-          "logs"
-        )
-      );
-    }
-  };
-}
-function unwrapObject(value, key) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-  return key in value ? value[key] : value;
-}
-
-export {
-  SftRecipeSchema,
-  ManagedSftRecipeSchema,
-  TrainingAcceptanceGroupReferenceSchema,
-  TrainingAcceptanceGroupSummarySchema,
-  TrainingAcceptanceGroupPageSchema,
-  TrainingAcceptanceGroupQuerySchema,
-  TrainingCheckpointRecoveryResourceApprovalSchema,
-  createTrainingCheckpointRecoveryResourceApproval,
-  TrainingCheckpointRecoveryRequestSchema,
-  TrainingPhysicalPlacementSchema,
-  TrainingPreparationRequestSchema,
-  TrainingPreparationPlanContentSchema,
-  TrainingPreparationPlanSchema,
-  TrainingPreparationReceiptSchema,
-  TrainingPreparationControlSchema,
-  TrainingPreparationListQuerySchema,
-  TrainingPreparationPageSchema,
-  parseAndVerifyTrainingPreparationReceipt,
-  TrainingEstimateSourceSchema,
-  TrainingEstimateRequestSchema,
-  TrainingEstimateComponentSchema,
-  trainingEstimateSourceIdentity,
-  TrainingEstimateSchema,
-  TrainingQueueStatusSchema,
-  TrainingHarnessSourcePublicationSchema,
-  TrainingCandidateDecisionRequestSchema,
-  TrainingCandidateDecisionSchema,
-  trainingCandidateDecisionHash,
-  parseAndVerifyTrainingCandidateDecision,
-  TrainingEvaluationTaskResultSchema,
-  TrainingEvaluationTaskPageSchema,
-  trainingEvaluationTaskPageHash,
-  parseAndVerifyTrainingEvaluationTaskPage,
-  deterministicTrainingRewardSource,
-  TRAINING_EVALUATION_SOURCE_PATH,
-  TrainingEvaluationSourceSchema,
-  assertTrainingEvaluationIsolation,
-  trainingEvaluationSourceRef,
-  TrainingInputArtifactUploadSchema,
-  TrainingInputArtifactSchema,
-  trainingInputArtifactUploadHash,
-  parseAndVerifyTrainingInputArtifactUpload,
-  TrainingJobKindSchema,
-  TrainingJobStateSchema,
-  TrainingCapabilityRequirementSchema,
-  TrainingJobSourceSchema,
-  RewardModelTrainingRequestSchema,
-  TrainingQualificationBaseModelSchema,
-  PolicyOptimizationRequestSchema,
-  TrainingJobRequestSchema,
-  TrainingJobApprovalSchema,
-  TrainingJobSubmissionSchema,
-  trainingJobSubmissionHash,
-  parseAndVerifyTrainingJobSubmission,
-  TrainingJobRecoverySchema,
-  TrainingJobSchema,
-  TrainingJobPageSchema,
-  TrainingJobEventSchema,
-  TrainingJobLogSchema,
-  TrainingJobControlRequestSchema,
-  TrainingJobOutputSchema,
-  TrainingQualificationEvidenceSchema,
-  TrainingExecutionReceiptSchema,
-  trainingExecutionReceiptHash,
-  parseAndVerifyTrainingExecutionReceipt,
-  assertTrainingQualificationReceipt,
-  TrainingJobOutputsSchema,
-  TrainingPolicyLoraCapabilitiesSchema,
-  supportsTrainingPolicyLoraRank,
-  TrainingCapabilitiesSchema,
-  createTrainingClient
-};
-//# sourceMappingURL=chunk-GJRXJL6G.js.map