openpond-sdk 0.0.12 → 0.0.14

package/dist/training.js

@@ -0,0 +1,691 @@
+// src/training.ts
+import { z as z2 } from "zod";
+
+// src/model-projects.ts
+import { z } from "zod";
+
+// 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_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),
+  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"),
+  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 HostedModelProjectLinkSchema = z.object({
+  schemaVersion: z.literal("openpond.hostedModelProjectLink.v1"),
+  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,
+      releaseId: IdSchema,
+      releaseRevision: z.number().int().positive(),
+      releaseHash: HashSchema,
+      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 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: ModelProjectTrainingSetupSchema,
+  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: ModelProjectTrainingSetupSchema,
+  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 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(),
+  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", [
+  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),
+  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),
+  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(),
+  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();
+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 configuredHeaders = typeof input.headers === "function" ? await input.headers() : input.headers ?? {};
+    const 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)
+      }
+    });
+    const body = parseBoundedJson(
+      await response.text(),
+      TRAINING_API_RESPONSE_MAX_BYTES,
+      "Training API response"
+    );
+    if (!response.ok) throw trainingApiError(body, response.status);
+    return body;
+  }
+  return {
+    async capabilities() {
+      return TrainingCapabilitiesSchema.parse(
+        unwrapObject(await request("/v1/training/capabilities"), "capabilities")
+      );
+    },
+    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 unwrapObject(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  return key in value ? value[key] : value;
+}
+function trainingApiError(value, status) {
+  const parsed = TrainingApiErrorSchema.safeParse(value);
+  if (parsed.success) {
+    return new OpenPondTrainingApiError(status, parsed.data);
+  }
+  return new OpenPondProtocolError(
+    "invalid_error_response",
+    `Training request failed with HTTP ${status} and an invalid error envelope.`
+  );
+}
+export {
+  OPENPOND_TRAINING_MEDIA_TYPE,
+  OPENPOND_TRAINING_PROTOCOL_MAJOR,
+  OpenPondProtocolError,
+  OpenPondTrainingApiError,
+  PolicyOptimizationRequestSchema,
+  RewardModelTrainingRequestSchema,
+  TRAINING_API_RESPONSE_MAX_BYTES,
+  TRAINING_JOB_SUBMISSION_MAX_BYTES,
+  TrainingApiErrorSchema,
+  TrainingCapabilitiesSchema,
+  TrainingCapabilityRequirementSchema,
+  TrainingExecutionReceiptSchema,
+  TrainingJobApprovalSchema,
+  TrainingJobControlRequestSchema,
+  TrainingJobEventSchema,
+  TrainingJobKindSchema,
+  TrainingJobLogSchema,
+  TrainingJobOutputSchema,
+  TrainingJobOutputsSchema,
+  TrainingJobPageSchema,
+  TrainingJobRequestSchema,
+  TrainingJobSchema,
+  TrainingJobSourceSchema,
+  TrainingJobStateSchema,
+  TrainingJobSubmissionSchema,
+  assertCanonicalPayloadSize,
+  canonicalJson,
+  canonicalJsonByteLength,
+  canonicalSha256,
+  createTrainingClient,
+  parseAndVerifyTrainingJobSubmission,
+  parseBoundedJson,
+  trainingJobSubmissionHash
+};
+//# sourceMappingURL=training.js.map