openpond-sdk 0.3.3 → 0.4.0

package/dist/training.js

@@ -1,826 +1,47 @@
-// src/training.ts
-import { z as z2 } from "zod";
-
-// src/model-projects.ts
-import { z } from "zod";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-
-// src/protocol.ts
-var OPENPOND_TRAINING_PROTOCOL_MAJOR = 2;
-var OPENPOND_TRAINING_MEDIA_TYPE = "application/vnd.openpond.training+json;version=2";
-var TRAINING_JOB_SUBMISSION_MAX_BYTES = 1048576;
-var TRAINING_INPUT_ARTIFACT_MAX_BYTES = 67108864;
-var TRAINING_API_RESPONSE_MAX_BYTES = 8388608;
-var OpenPondProtocolError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "OpenPondProtocolError";
-    this.code = code;
-  }
-};
-function canonicalJson(value) {
-  return JSON.stringify(normalizeCanonicalJson(value));
-}
-function canonicalJsonByteLength(value) {
-  return new TextEncoder().encode(canonicalJson(value)).byteLength;
-}
-async function canonicalSha256(value) {
-  const bytes = new TextEncoder().encode(canonicalJson(value));
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-  return Array.from(
-    new Uint8Array(digest),
-    (byte) => byte.toString(16).padStart(2, "0")
-  ).join("");
-}
-function assertCanonicalPayloadSize(value, maximumBytes, label) {
-  const actualBytes = canonicalJsonByteLength(value);
-  if (actualBytes > maximumBytes) {
-    throw new OpenPondProtocolError(
-      "payload_too_large",
-      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`
-    );
-  }
-}
-function parseBoundedJson(text, maximumBytes, label) {
-  const actualBytes = new TextEncoder().encode(text).byteLength;
-  if (actualBytes > maximumBytes) {
-    throw new OpenPondProtocolError(
-      "response_too_large",
-      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`
-    );
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new OpenPondProtocolError(
-      "invalid_json",
-      `${label} was not valid JSON.`
-    );
-  }
-}
-function normalizeCanonicalJson(value) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new OpenPondProtocolError(
-        "non_json_value",
-        "Canonical JSON cannot contain a non-finite number."
-      );
-    }
-    return Object.is(value, -0) ? 0 : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => normalizeCanonicalJson(entry));
-  }
-  if (typeof value === "object") {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw new OpenPondProtocolError(
-        "non_json_value",
-        "Canonical JSON accepts only plain objects."
-      );
-    }
-    const result = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") {
-        throw new OpenPondProtocolError(
-          "non_json_value",
-          `Canonical JSON cannot contain ${typeof entry} at ${key}.`
-        );
-      }
-      result[key] = normalizeCanonicalJson(entry);
-    }
-    return result;
-  }
-  throw new OpenPondProtocolError(
-    "non_json_value",
-    `Canonical JSON cannot contain ${typeof value}.`
-  );
-}
-
-// src/model-projects.ts
-var IdSchema = z.string().trim().min(1).max(500);
-var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z.string().datetime({ offset: true });
-var ModelProjectImmutableRefSchema = z.object({
-  id: IdSchema,
-  contentHash: HashSchema
-}).strict();
-var ModelProjectVersionedRefSchema = ModelProjectImmutableRefSchema.extend({
-  revision: z.number().int().positive()
-}).strict();
-var ModelProjectBaseModelSchema = z.object({
-  schemaVersion: z.literal("openpond.baseModelPreference.v1"),
-  modelId: IdSchema,
-  revision: z.string().trim().min(1).max(256).nullable(),
-  tokenizerRevision: z.string().trim().min(1).max(256).nullable(),
-  chatTemplateHash: z.string().trim().min(8).max(256).nullable(),
-  modelAssetId: IdSchema.nullable(),
-  source: z.enum(["managed", "local", "builtin"])
-}).strict();
-var ModelProjectTrainingMethodSchema = z.enum([
-  "sft",
-  "dpo",
-  "grpo",
-  "ppo",
-  "sdft",
-  "opd",
-  "opsd",
-  "sdpo"
-]);
-var ModelProjectRecipeDocumentSchema = z.object({
-  schemaVersion: z.string().regex(/^openpond\.[A-Za-z0-9]+Recipe\.v\d+$/),
-  method: ModelProjectTrainingMethodSchema,
-  parameterization: z.enum(["lora", "full"])
-}).catchall(z.unknown());
-var ModelProjectTrainingSetupSchema = z.object({
-  tasksetRef: ModelProjectVersionedRefSchema.nullable().default(null),
-  rewardBindingRef: ModelProjectVersionedRefSchema.nullable().optional(),
-  tasksetRelease: ModelProjectImmutableRefSchema.nullable().default(null),
-  harnessRelease: ModelProjectImmutableRefSchema.nullable().default(null),
-  baseModel: ModelProjectBaseModelSchema.nullable().default(null),
-  method: ModelProjectTrainingMethodSchema.nullable().default(null),
-  destinationId: IdSchema.nullable().default(null),
-  managedRolloutPlacement: z.enum(["local", "remote"]).default("remote"),
-  managedGpuPlacementObjective: z.enum(["fast", "balanced", "economical"]).default("balanced"),
-  managedGpuRequirement: z.enum(["any", "h100_hbm3"]).default("any"),
-  runPreset: z.enum(["small", "standard", "custom", "small_experiment"]).nullable().default(null),
-  recipe: ModelProjectRecipeDocumentSchema.nullable().default(null),
-  preferredMaximumSpendUsd: z.number().nonnegative().nullable().default(null),
-  preferredRetentionDays: z.number().int().nonnegative().nullable().default(null)
-}).strict();
-var HostedModelProjectTrainingSetupSchema = ModelProjectTrainingSetupSchema.omit({ managedGpuRequirement: true });
-var HostedModelProjectLinkSchema = z.object({
-  schemaVersion: z.literal("openpond.hostedModelProjectLink.v1"),
-  apiOrigin: z.string().url().refine((value) => new URL(value).origin === value, "Use a canonical API origin.").nullable().default(null),
-  teamId: IdSchema,
-  projectId: IdSchema,
-  portableProjectId: IdSchema,
-  revision: z.number().int().positive(),
-  etag: HashSchema,
-  syncedSourceRevision: z.number().int().positive(),
-  syncedAt: TimestampSchema,
-  tasksets: z.array(
-    z.object({
-      localTasksetId: IdSchema,
-      localTasksetHash: HashSchema.nullable().default(null),
-      releaseId: IdSchema,
-      releaseRevision: z.number().int().positive(),
-      releaseHash: HashSchema,
-      packageHash: HashSchema.nullable().default(null),
-      hostedTasksetId: IdSchema,
-      syncedAt: TimestampSchema
-    }).strict()
-  ).max(1e4).default([])
-}).strict();
-var ModelProjectTasksetSyncSchema = z.object({
-  localTasksetId: IdSchema,
-  releaseId: IdSchema,
-  releaseRevision: z.number().int().positive(),
-  releaseHash: HashSchema,
-  state: z.enum(["syncing", "synced", "sync_failed"]),
-  hostedTasksetId: IdSchema.nullable().default(null),
-  lastAttemptAt: TimestampSchema,
-  syncedAt: TimestampSchema.nullable().default(null),
-  lastError: z.string().trim().min(1).max(5e3).nullable().default(null)
-}).strict();
-var ModelProjectSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProject.v2"),
-  id: IdSchema,
-  profileId: IdSchema,
-  revision: z.number().int().positive().default(1),
-  name: z.string().trim().min(1).max(200),
-  objective: z.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: ModelProjectTrainingSetupSchema,
-  hosted: HostedModelProjectLinkSchema.nullable().default(null),
-  tasksetSyncs: z.array(ModelProjectTasksetSyncSchema).max(1e4).default([]),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-}).strict();
-var ModelProjectEditableSchema = ModelProjectSchema.pick({
-  id: true,
-  profileId: true,
-  name: true,
-  objective: true,
-  defaultBaseModel: true,
-  defaultDestinationId: true,
-  trainingSetup: true
-});
-var ModelProjectSaveRequestSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProjectSave.v1"),
-  operationId: IdSchema,
-  expectedRevision: z.number().int().nonnegative(),
-  project: ModelProjectEditableSchema
-}).strict();
-var ModelProjectConfigurationCheckSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProjectConfigurationCheck.v1"),
-  configurationHash: HashSchema,
-  projectId: IdSchema,
-  expectedRevision: z.number().int().nonnegative(),
-  checkedAt: TimestampSchema,
-  canSave: z.boolean(),
-  deferred: z.array(z.enum(["base_model", "taskset"])).max(2),
-  findings: z.array(z.object({
-    code: IdSchema,
-    severity: z.enum(["error", "warning"]),
-    message: z.string().min(1).max(5e3),
-    field: z.string().min(1).max(500).nullable()
-  }).strict()).max(100)
-}).strict();
-var ModelProjectBaseModelCandidateSchema = z.object({
-  id: IdSchema,
-  name: z.string().min(1).max(500),
-  available: z.boolean(),
-  preference: ModelProjectBaseModelSchema
-}).strict();
-var HostedModelProjectSyncSchema = z.object({
-  schemaVersion: z.literal("openpond.hostedModelProjectSync.v2"),
-  portableProjectId: IdSchema,
-  name: z.string().trim().min(1).max(200),
-  objective: z.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: HostedModelProjectTrainingSetupSchema,
-  sourceRevision: z.number().int().positive(),
-  sourceUpdatedAt: TimestampSchema,
-  expectedEtag: HashSchema.nullable().default(null)
-}).strict();
-var HostedModelProjectSummarySchema = z.object({
-  id: IdSchema,
-  teamId: IdSchema,
-  portableProjectId: IdSchema,
-  name: z.string().trim().min(1).max(200),
-  objective: z.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: HostedModelProjectTrainingSetupSchema,
-  sourceRevision: z.number().int().positive(),
-  sourceUpdatedAt: TimestampSchema,
-  revision: z.number().int().positive(),
-  etag: HashSchema,
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-}).strict();
-var ModelProjectResourceSummarySchema = z.object({
-  kind: z.enum([
-    "taskset_release",
-    "harness_release",
-    "dataset_release",
-    "evidence_set",
-    "model_version",
-    "reward_model_version",
-    "evaluation_receipt"
-  ]),
-  ref: ModelProjectImmutableRefSchema,
-  role: z.string().trim().min(1).max(200).nullable().default(null),
-  updatedAt: TimestampSchema
-}).strict();
-var HostedModelProjectDetailSchema = z.object({
-  project: HostedModelProjectSummarySchema,
-  resources: z.array(ModelProjectResourceSummarySchema).max(1e4),
-  jobCount: z.number().int().nonnegative(),
-  latestJobIds: z.array(IdSchema).max(100)
-}).strict();
-var ModelProjectApiErrorSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProjectApiError.v2"),
-  code: z.string().trim().min(1).max(200),
-  message: z.string().trim().min(1).max(5e3),
-  retryable: z.boolean().default(false),
-  requestId: z.string().trim().min(1).max(500).nullable().default(null),
-  details: z.record(z.string(), z.unknown()).default({})
-}).strict();
-
-// src/training.ts
-var IdSchema2 = z2.string().trim().min(1).max(500);
-var HashSchema2 = z2.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema2 = z2.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z2.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z2.string().trim().min(1).max(500),
-  sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z2.unknown(),
-  contentHash: HashSchema2
-}).strict();
-var TrainingInputArtifactSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingInputArtifact.v2"),
-  kind: z2.enum(["portable_training_bundle", "reward_model_dataset"]),
-  sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z2.string().trim().min(1).max(2e3),
-  contentHash: HashSchema2,
-  sizeBytes: z2.number().int().positive(),
-  createdAt: TimestampSchema2
-}).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 = z2.enum([
-  "reward_model_train",
-  "policy_optimize"
-]);
-var TrainingJobStateSchema = z2.enum([
-  "queued",
-  "admitting",
-  "provisioning",
-  "running",
-  "stopping",
-  "cancelling",
-  "succeeded",
-  "failed",
-  "cancelled"
-]);
-var TrainingCapabilityRequirementSchema = z2.object({
-  id: IdSchema2,
-  version: z2.string().trim().min(1).max(200).nullable().default(null),
-  required: z2.boolean().default(true)
-}).strict();
-var TrainingJobSourceSchema = z2.object({
-  modelProject: z2.object({
-    id: IdSchema2,
-    portableProjectId: IdSchema2,
-    revision: z2.number().int().positive(),
-    contentHash: HashSchema2
-  }).strict(),
-  harnessRunManifest: ModelProjectImmutableRefSchema,
-  harnessRelease: ModelProjectImmutableRefSchema,
-  taskset: ModelProjectVersionedRefSchema,
-  tasksetRelease: ModelProjectImmutableRefSchema,
-  dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z2.array(ModelProjectImmutableRefSchema).max(1e4)
-}).strict();
-var RewardModelTrainingRequestSchema = z2.object({
-  kind: z2.literal("reward_model_train"),
-  baseModel: ModelProjectBaseModelSchema,
-  preferenceDatasetRelease: ModelProjectImmutableRefSchema,
-  processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z2.object({
-    schemaVersion: z2.literal("openpond.rewardModelRecipe.v1"),
-    method: z2.literal("reward_model"),
-    parameterization: z2.literal("lora_with_scalar_head")
-  }).catchall(z2.unknown())
-}).strict();
-var DeterministicRewardSourceSchema = z2.object({
-  kind: z2.literal("deterministic"),
-  grader: ModelProjectImmutableRefSchema,
-  composer: ModelProjectImmutableRefSchema.nullable().default(null)
-}).strict();
-var LearnedRewardSourceSchema = z2.object({
-  kind: z2.literal("learned_reward"),
-  rewardModelVersion: ModelProjectImmutableRefSchema,
-  qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z2.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z2.object({
-    artifactRef: z2.string().trim().min(1).max(2e3),
-    contentHash: HashSchema2,
-    executionReceipt: ModelProjectImmutableRefSchema
-  }).strict(),
-  processorRelease: ModelProjectImmutableRefSchema,
-  rewardComposerRelease: ModelProjectImmutableRefSchema
-}).strict();
-var PolicyOptimizationRequestSchema = z2.object({
-  kind: z2.literal("policy_optimize"),
-  baseModel: ModelProjectBaseModelSchema,
-  recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z2.discriminatedUnion("kind", [
-    DeterministicRewardSourceSchema,
-    LearnedRewardSourceSchema
-  ]),
-  resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
-}).strict();
-var TrainingJobRequestSchema = z2.discriminatedUnion("kind", [
+import {
+  OpenPondTrainingApiError,
+  PolicyOptimizationRequestSchema,
   RewardModelTrainingRequestSchema,
-  PolicyOptimizationRequestSchema
-]);
-var TrainingJobApprovalSchema = z2.object({
-  approvalHash: HashSchema2,
-  approvedAt: TimestampSchema2,
-  exportApproved: z2.boolean(),
-  maximumSpendUsd: z2.number().nonnegative(),
-  retentionDays: z2.number().int().nonnegative().nullable(),
-  region: z2.string().trim().min(1).max(200).nullable().default(null)
-}).strict();
-var TrainingJobSubmissionSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z2.string().trim().min(1).max(500),
-  name: z2.string().trim().min(1).max(200),
-  source: TrainingJobSourceSchema,
-  job: TrainingJobRequestSchema,
-  requestedCapabilities: z2.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z2.enum(["fast", "balanced", "economical"]),
-  budget: z2.object({
-    maximumSpendUsd: z2.number().nonnegative(),
-    maximumWallSeconds: z2.number().int().positive()
-  }).strict(),
-  approval: TrainingJobApprovalSchema,
-  contentHash: HashSchema2
-}).strict().superRefine((submission, context) => {
-  if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
-    context.addIssue({
-      code: "custom",
-      path: ["approval", "maximumSpendUsd"],
-      message: "Approved spend must equal the immutable Job budget."
-    });
-  }
-});
-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 TrainingJobSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJob.v2"),
-  id: IdSchema2,
-  teamId: IdSchema2,
-  kind: TrainingJobKindSchema,
-  modelProjectId: IdSchema2,
-  portableProjectId: IdSchema2,
-  sourceProjectRevision: z2.number().int().positive(),
-  submissionHash: HashSchema2,
-  state: TrainingJobStateSchema,
-  phase: z2.string().trim().min(1).max(200),
-  version: z2.number().int().nonnegative(),
-  progress: z2.number().min(0).max(1),
-  rolloutProgress: z2.object({
-    groupsCompleted: z2.number().int().nonnegative(),
-    groupsTarget: z2.number().int().nonnegative(),
-    optimizerUpdatesApplied: z2.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z2.number().int().nonnegative()
-  }).strict(),
-  accruedSpendUsd: z2.number().nonnegative(),
-  terminalReason: z2.string().trim().min(1).max(5e3).nullable(),
-  createdAt: TimestampSchema2,
-  updatedAt: TimestampSchema2,
-  completedAt: TimestampSchema2.nullable()
-}).strict();
-var TrainingJobPageSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJobPage.v2"),
-  jobs: z2.array(TrainingJobSchema).max(1e3),
-  nextCursor: z2.string().trim().min(1).max(2e3).nullable()
-}).strict();
-var TrainingJobEventSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJobEvent.v2"),
-  id: IdSchema2,
-  jobId: IdSchema2,
-  sequence: z2.number().int().nonnegative(),
-  type: IdSchema2,
-  phase: z2.string().trim().min(1).max(200),
-  message: z2.string().trim().min(1).max(5e3).nullable(),
-  data: z2.record(z2.string(), z2.unknown()).default({}),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingJobLogSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJobLog.v2"),
-  jobId: IdSchema2,
-  sequence: z2.number().int().nonnegative(),
-  level: z2.enum(["debug", "info", "warning", "error"]),
-  message: z2.string().max(2e4),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingJobControlRequestSchema = z2.object({ expectedVersion: z2.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJobOutput.v2"),
-  id: IdSchema2,
-  jobId: IdSchema2,
-  kind: z2.enum([
-    "checkpoint",
-    "adapter",
-    "scorer",
-    "metrics",
-    "evaluation",
-    "trace",
-    "receipt"
-  ]),
-  artifactRef: z2.string().trim().min(1).max(2e3),
-  contentHash: HashSchema2,
-  sizeBytes: z2.number().int().nonnegative(),
-  metadata: z2.record(z2.string(), z2.unknown()).default({}),
-  createdAt: TimestampSchema2
-}).strict();
-var TrainingExecutionReceiptSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingExecutionReceipt.v2"),
-  id: IdSchema2,
-  teamId: IdSchema2,
-  jobId: IdSchema2,
-  submissionHash: HashSchema2,
-  manifestHash: HashSchema2,
-  recipeHash: HashSchema2,
-  capabilityHash: HashSchema2,
-  runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z2.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z2.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z2.number().nonnegative(),
-  durationSeconds: z2.number().nonnegative(),
-  cleanupComplete: z2.boolean(),
-  issuer: IdSchema2,
-  issuedAt: TimestampSchema2,
-  signature: z2.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 = IdSchema2.parse(expected.id);
-  const expectedHash = HashSchema2.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 !== IdSchema2.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 !== IdSchema2.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."
-    );
-  }
-  return receipt;
-}
-var TrainingJobOutputsSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z2.array(TrainingJobOutputSchema).max(1e4),
-  receipt: TrainingExecutionReceiptSchema.nullable()
-}).strict();
-var TrainingApiErrorSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingApiError.v2"),
-  code: z2.string().trim().min(1).max(200),
-  message: z2.string().trim().min(1).max(5e3),
-  retryable: z2.boolean().default(false),
-  requestId: z2.string().trim().min(1).max(500).nullable().default(null),
-  details: z2.record(z2.string(), z2.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 TrainingCapabilitiesSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingCapabilities.v2"),
-  capabilityHash: HashSchema2,
-  jobKinds: z2.array(TrainingJobKindSchema),
-  methods: z2.array(z2.string().trim().min(1).max(200)),
-  placements: z2.array(
-    z2.enum(["local", "remote", "colocated", "provider_native"])
-  ),
-  controls: z2.object({
-    cancel: z2.boolean(),
-    stopAfterGroup: z2.boolean(),
-    resumeFromCheckpoint: z2.boolean()
-  }).strict(),
-  limits: z2.object({
-    maximumSpendUsd: z2.number().nonnegative(),
-    maximumWallSeconds: z2.number().int().positive(),
-    maximumArtifactBytes: z2.number().int().positive()
-  }).strict(),
-  checkedAt: TimestampSchema2,
-  expiresAt: TimestampSchema2
-}).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) {
-    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 = parseBoundedJson(
-        await response.text(),
-        TRAINING_API_RESPONSE_MAX_BYTES,
-        "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."
-    );
-  }
-  return {
-    async capabilities() {
-      return TrainingCapabilitiesSchema.parse(
-        unwrapObject(await request("/v1/training/capabilities"), "capabilities")
-      );
-    },
-    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", IdSchema2.parse(options.modelProjectId));
-      }
-      if (options.cursor) {
-        parameters.set("cursor", z2.string().trim().min(1).max(2e3).parse(options.cursor));
-      }
-      if (options.limit !== void 0) {
-        parameters.set(
-          "limit",
-          String(z2.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(IdSchema2.parse(jobId))}`),
-          "job"
-        )
-      );
-    },
-    async cancelJob(jobId, expectedVersion) {
-      const control = TrainingJobControlRequestSchema.parse({ expectedVersion });
-      return TrainingJobSchema.parse(
-        unwrapObject(
-          await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema2.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(IdSchema2.parse(jobId))}/stop-after-group`,
-            { method: "POST", body: JSON.stringify(control) }
-          ),
-          "job"
-        )
-      );
-    },
-    async events(jobId) {
-      return z2.array(TrainingJobEventSchema).parse(
-        unwrapObject(
-          await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/events`
-          ),
-          "events"
-        )
-      );
-    },
-    async outputs(jobId) {
-      return TrainingJobOutputsSchema.parse(
-        await request(
-          `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/outputs`
-        )
-      );
-    },
-    async logs(jobId) {
-      return z2.array(TrainingJobLogSchema).max(1e5).parse(
-        unwrapObject(
-          await request(
-            `/v1/training/jobs/${encodeURIComponent(IdSchema2.parse(jobId))}/logs`
-          ),
-          "logs"
-        )
-      );
-    }
-  };
-}
-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.`
-  );
-}
+  TrainingApiErrorSchema,
+  TrainingCapabilitiesSchema,
+  TrainingCapabilityRequirementSchema,
+  TrainingExecutionReceiptSchema,
+  TrainingInputArtifactSchema,
+  TrainingInputArtifactUploadSchema,
+  TrainingJobApprovalSchema,
+  TrainingJobControlRequestSchema,
+  TrainingJobEventSchema,
+  TrainingJobKindSchema,
+  TrainingJobLogSchema,
+  TrainingJobOutputSchema,
+  TrainingJobOutputsSchema,
+  TrainingJobPageSchema,
+  TrainingJobRequestSchema,
+  TrainingJobSchema,
+  TrainingJobSourceSchema,
+  TrainingJobStateSchema,
+  TrainingJobSubmissionSchema,
+  createTrainingClient,
+  parseAndVerifyTrainingExecutionReceipt,
+  parseAndVerifyTrainingInputArtifactUpload,
+  parseAndVerifyTrainingJobSubmission,
+  trainingExecutionReceiptHash,
+  trainingInputArtifactUploadHash,
+  trainingJobSubmissionHash
+} from "./chunk-AVW35YOH.js";
+import {
+  OPENPOND_TRAINING_MEDIA_TYPE,
+  OPENPOND_TRAINING_PROTOCOL_MAJOR,
+  OpenPondProtocolError,
+  TRAINING_API_RESPONSE_MAX_BYTES,
+  TRAINING_INPUT_ARTIFACT_MAX_BYTES,
+  TRAINING_JOB_SUBMISSION_MAX_BYTES,
+  assertCanonicalPayloadSize,
+  canonicalJson,
+  canonicalJsonByteLength,
+  canonicalSha256,
+  parseBoundedJson
+} from "./chunk-5PRP457R.js";
 export {
   OPENPOND_TRAINING_MEDIA_TYPE,
   OPENPOND_TRAINING_PROTOCOL_MAJOR,