openpond-sdk 0.9.0 → 0.9.1

package/dist/{chunk-KIBRMKJQ.js → chunk-JCPLAIZL.js}

@@ -19,59 +19,111 @@ import {
   ImmutableReleaseRefSchema
 } from "./chunk-QUOW6URQ.js";
 
+// src/training-acceptance.ts
+import { z } from "zod";
+import { assertAcceptanceGroupSnapshot, AcceptanceGroupSnapshotSchema } from "@openpond/evals/learning";
+var Id = z.string().trim().min(1).max(240);
+var TrainingAcceptanceGroupReferenceSchema = ModelProjectImmutableRefSchema.extend({ revision: z.number().int().positive() }).strict();
+var TrainingAcceptanceGroupSummarySchema = TrainingAcceptanceGroupReferenceSchema.extend({
+  teamId: Id,
+  jobId: Id,
+  plan: ModelProjectImmutableRefSchema,
+  baseline: ModelProjectImmutableRefSchema,
+  candidate: ModelProjectImmutableRefSchema,
+  state: AcceptanceGroupSnapshotSchema.shape.state,
+  updatedAt: z.string().datetime()
+}).strict();
+var TrainingAcceptanceGroupPageSchema = z.object({
+  schemaVersion: z.literal("openpond.trainingAcceptanceGroupPage.v1"),
+  teamId: Id,
+  jobId: Id,
+  groups: z.array(TrainingAcceptanceGroupSummarySchema).max(100),
+  nextCursor: Id.nullable()
+}).strict();
+var TrainingAcceptanceGroupQuerySchema = z.object({
+  cursor: Id.optional(),
+  limit: z.number().int().min(1).max(100).default(25)
+}).strict();
+function createTrainingAcceptanceClient(request) {
+  const route = (target) => {
+    Id.parse(target.teamId);
+    return `/v1/training/jobs/${encodeURIComponent(Id.parse(target.jobId))}/acceptance-groups`;
+  };
+  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(Id.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 z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/training-preparations.ts
-import { z } from "zod";
-var Id = z.string().trim().min(1).max(191);
-var Hash = z.string().regex(/^[a-f0-9]{64}$/);
-var TrainingPreparationRequestSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingPreparationRequest.v1"),
-  teamId: Id,
-  operationId: Id,
-  projectId: Id.nullable(),
-  configuration: z.object({ id: Id, expectedRevision: z.number().int().positive(), expectedEtag: Hash }).strict(),
+import { z as z2 } from "zod";
+var Id2 = z2.string().trim().min(1).max(191);
+var Hash = z2.string().regex(/^[a-f0-9]{64}$/);
+var TrainingPreparationRequestSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingPreparationRequest.v1"),
+  teamId: Id2,
+  operationId: Id2,
+  projectId: Id2.nullable(),
+  configuration: z2.object({ id: Id2, expectedRevision: z2.number().int().positive(), expectedEtag: Hash }).strict(),
   batch: ModelProjectVersionedRefSchema,
-  name: z.string().trim().min(1).max(191),
-  maximumSpendUsd: z.number().finite().positive().max(1e6)
+  name: z2.string().trim().min(1).max(191),
+  maximumSpendUsd: z2.number().finite().positive().max(1e6)
 }).strict();
-var TrainingPreparationPlanContentSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingPreparationPlan.v1"),
-  id: Id,
-  creatorUserId: Id,
+var TrainingPreparationPlanContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingPreparationPlan.v1"),
+  id: Id2,
+  creatorUserId: Id2,
   request: TrainingPreparationRequestSchema,
   requestHash: Hash,
-  source: z.lazy(() => TrainingJobSourceSchema),
+  source: z2.lazy(() => TrainingJobSourceSchema),
   submissionHash: Hash,
-  createdAt: z.string().datetime({ offset: true })
+  createdAt: z2.string().datetime({ offset: true })
 }).strict();
 var TrainingPreparationPlanSchema = TrainingPreparationPlanContentSchema.extend({ contentHash: Hash }).strict();
-var TrainingPreparationReceiptSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingPreparationReceipt.v1"),
+var TrainingPreparationReceiptSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingPreparationReceipt.v1"),
   plan: TrainingPreparationPlanSchema,
-  revision: z.number().int().positive(),
-  state: z.enum(["prepared", "submitted", "cancelled"]),
-  jobId: Id.nullable()
+  revision: z2.number().int().positive(),
+  state: z2.enum(["prepared", "submitted", "cancelled"]),
+  jobId: Id2.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 = z.object({
-  teamId: Id,
+var TrainingPreparationControlSchema = z2.object({
+  teamId: Id2,
   planHash: Hash,
-  expectedRevision: z.number().int().positive()
+  expectedRevision: z2.number().int().positive()
 }).strict();
-var TrainingPreparationListQuerySchema = z.object({
-  projectId: Id.optional(),
-  state: z.enum(["prepared", "submitted", "cancelled"]).optional(),
-  afterId: Id.optional(),
-  limit: z.number().int().min(1).max(100).default(25)
+var TrainingPreparationListQuerySchema = z2.object({
+  projectId: Id2.optional(),
+  state: z2.enum(["prepared", "submitted", "cancelled"]).optional(),
+  afterId: Id2.optional(),
+  limit: z2.number().int().min(1).max(100).default(25)
 }).strict();
-var TrainingPreparationPageSchema = z.object({
-  schemaVersion: z.literal("openpond.trainingPreparationPage.v1"),
-  teamId: Id,
-  items: z.array(TrainingPreparationReceiptSchema).max(100),
-  nextCursor: Id.nullable()
+var TrainingPreparationPageSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingPreparationPage.v1"),
+  teamId: Id2,
+  items: z2.array(TrainingPreparationReceiptSchema).max(100),
+  nextCursor: Id2.nullable()
 }).strict();
 async function parseAndVerifyTrainingPreparationReceipt(value) {
   const receipt = TrainingPreparationReceiptSchema.parse(value);
@@ -91,7 +143,7 @@ function createTrainingPreparationClient(request) {
   return {
     /** Discover the authenticated user's retained preparations without creating jobs. */
     async listPreparations(teamId, input = {}) {
-      const scope = Id.parse(teamId);
+      const scope = Id2.parse(teamId);
       const query = TrainingPreparationListQuerySchema.parse(input);
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) params.set(key, String(value));
@@ -116,18 +168,18 @@ function createTrainingPreparationClient(request) {
       return receipt;
     },
     async getPreparation(teamId, id) {
-      return read(await request(`/v1/training/preparations/${encodeURIComponent(Id.parse(id))}`), Id.parse(teamId), id);
+      return read(await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id))}`), Id2.parse(teamId), id);
     },
     async startPreparation(id, input) {
       const parsed = TrainingPreparationControlSchema.parse(input);
-      const receipt = await read(await request(`/v1/training/preparations/${encodeURIComponent(Id.parse(id))}/start`, { method: "POST", body: JSON.stringify(parsed) }), parsed.teamId, id);
+      const receipt = await read(await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id))}/start`, { method: "POST", body: JSON.stringify(parsed) }), parsed.teamId, id);
       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(id, input) {
       const parsed = TrainingPreparationControlSchema.parse(input);
-      const receipt = await read(await request(`/v1/training/preparations/${encodeURIComponent(Id.parse(id))}/cancel`, { method: "POST", body: JSON.stringify(parsed) }), parsed.teamId, id);
+      const receipt = await read(await request(`/v1/training/preparations/${encodeURIComponent(Id2.parse(id))}/cancel`, { method: "POST", body: JSON.stringify(parsed) }), parsed.teamId, id);
       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;
@@ -136,12 +188,12 @@ function createTrainingPreparationClient(request) {
 }
 
 // src/training-harness-sources.ts
-import { z as z2 } from "zod";
-var TrainingHarnessSourcePublicationSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingHarnessSourcePublication.v1"),
+import { z as z3 } from "zod";
+var TrainingHarnessSourcePublicationSchema = z3.object({
+  schemaVersion: z3.literal("openpond.trainingHarnessSourcePublication.v1"),
   harnessRelease: ImmutableReleaseRefSchema,
-  sourcePackageHash: z2.string().regex(/^[a-f0-9]{64}$/),
-  sizeBytes: z2.number().int().positive().max(TRAINING_INPUT_ARTIFACT_MAX_BYTES)
+  sourcePackageHash: z3.string().regex(/^[a-f0-9]{64}$/),
+  sizeBytes: z3.number().int().positive().max(TRAINING_INPUT_ARTIFACT_MAX_BYTES)
 }).strict();
 function createTrainingHarnessSourceClient(request) {
   const route = (reference) => {
@@ -171,28 +223,28 @@ function createTrainingHarnessSourceClient(request) {
 }
 
 // src/training-candidate-decisions.ts
-import { z as z3 } from "zod";
-var IdSchema = /* @__PURE__ */ (() => z3.string().trim().min(1).max(500))();
-var HashSchema = /* @__PURE__ */ (() => z3.string().regex(/^[a-f0-9]{64}$/))();
-var TrainingCandidateDecisionRequestSchema = /* @__PURE__ */ (() => z3.object({
-  schemaVersion: z3.literal("openpond.trainingCandidateDecisionRequest.v1"),
+import { z as z4 } from "zod";
+var IdSchema = /* @__PURE__ */ (() => z4.string().trim().min(1).max(500))();
+var HashSchema = /* @__PURE__ */ (() => z4.string().regex(/^[a-f0-9]{64}$/))();
+var TrainingCandidateDecisionRequestSchema = /* @__PURE__ */ (() => z4.object({
+  schemaVersion: z4.literal("openpond.trainingCandidateDecisionRequest.v1"),
   teamId: IdSchema,
   jobId: IdSchema,
   artifact: ModelProjectImmutableRefSchema,
   evaluation: ModelProjectImmutableRefSchema,
   executionReceipt: ModelProjectImmutableRefSchema,
-  decision: z3.enum(["accepted", "rejected"]),
-  reason: z3.string().trim().min(1).max(5e3),
+  decision: z4.enum(["accepted", "rejected"]),
+  reason: z4.string().trim().min(1).max(5e3),
   idempotencyKey: IdSchema,
   expectedDecision: ModelProjectImmutableRefSchema.nullable()
 }).strict())();
-var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z3.object({
-  schemaVersion: z3.literal("openpond.trainingCandidateDecision.v1"),
+var TrainingCandidateDecisionSchema = /* @__PURE__ */ (() => z4.object({
+  schemaVersion: z4.literal("openpond.trainingCandidateDecision.v1"),
   id: IdSchema,
   request: TrainingCandidateDecisionRequestSchema,
-  revision: z3.number().int().positive(),
-  actor: z3.object({ userId: IdSchema, kind: z3.enum(["user", "api_key", "agent_delegate"]), id: IdSchema }).strict(),
-  decidedAt: z3.string().datetime({ offset: true }),
+  revision: z4.number().int().positive(),
+  actor: z4.object({ userId: IdSchema, kind: z4.enum(["user", "api_key", "agent_delegate"]), id: IdSchema }).strict(),
+  decidedAt: z4.string().datetime({ offset: true }),
   contentHash: HashSchema
 }).strict().superRefine((value, context) => {
   if (value.revision === 1 !== (value.request.expectedDecision === null)) {
@@ -229,7 +281,7 @@ function createTrainingCandidateDecisionClient(request) {
       IdSchema.parse(target.teamId);
       const reference = options.decision ? ModelProjectImmutableRefSchema.parse(options.decision) : void 0;
       const query = reference ? `?decisionId=${encodeURIComponent(reference.id)}` : "";
-      const response = z3.object({ decision: z3.unknown().nullable() }).strict().parse(await request(`${route(target)}${query}`));
+      const response = z4.object({ decision: z4.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)) {
@@ -246,38 +298,38 @@ function createTrainingCandidateDecisionClient(request) {
 }
 
 // src/training-evaluation-results.ts
-import { z as z4 } from "zod";
-var IdSchema2 = /* @__PURE__ */ (() => z4.string().trim().min(1).max(500))();
-var HashSchema2 = /* @__PURE__ */ (() => z4.string().regex(/^[a-f0-9]{64}$/))();
-var TrainingEvaluationTaskResultSchema = /* @__PURE__ */ (() => z4.object({
+import { z as z5 } from "zod";
+var IdSchema2 = /* @__PURE__ */ (() => z5.string().trim().min(1).max(500))();
+var HashSchema2 = /* @__PURE__ */ (() => z5.string().regex(/^[a-f0-9]{64}$/))();
+var TrainingEvaluationTaskResultSchema = /* @__PURE__ */ (() => z5.object({
   taskId: IdSchema2,
   taskSha256: HashSchema2,
   resultSha256: HashSchema2,
-  input: z4.object({
-    instruction: z4.string().max(1e6),
-    context: z4.record(z4.string(), z4.unknown())
+  input: z5.object({
+    instruction: z5.string().max(1e6),
+    context: z5.record(z5.string(), z5.unknown())
   }).strict(),
-  output: z4.string().max(1e6),
+  output: z5.string().max(1e6),
   outputSha256: HashSchema2,
-  score: z4.number().finite().min(0).max(1),
-  evidence: z4.object({
-    kind: z4.enum(["worker_command", "hosted_trace", "local_trace"]),
+  score: z5.number().finite().min(0).max(1),
+  evidence: z5.object({
+    kind: z5.enum(["worker_command", "hosted_trace", "local_trace"]),
     id: IdSchema2
   }).strict()
 }).strict())();
-var TrainingEvaluationTaskPageSchema = /* @__PURE__ */ (() => z4.object({
-  schemaVersion: z4.literal("openpond.trainingEvaluationTaskPage.v1"),
+var TrainingEvaluationTaskPageSchema = /* @__PURE__ */ (() => z5.object({
+  schemaVersion: z5.literal("openpond.trainingEvaluationTaskPage.v1"),
   jobId: IdSchema2,
   teamId: IdSchema2,
   evaluation: ModelProjectImmutableRefSchema,
-  kind: z4.enum(["baseline", "candidate"]),
-  policyVersion: z4.number().int().nonnegative(),
+  kind: z5.enum(["baseline", "candidate"]),
+  policyVersion: z5.number().int().nonnegative(),
   taskset: ModelProjectVersionedRefSchema,
   panelSha256: HashSchema2,
-  offset: z4.number().int().nonnegative(),
-  total: z4.number().int().min(1).max(1e4),
-  tasks: z4.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
-  nextCursor: z4.string().regex(/^[1-9]\d*$/).nullable(),
+  offset: z5.number().int().nonnegative(),
+  total: z5.number().int().min(1).max(1e4),
+  tasks: z5.array(TrainingEvaluationTaskResultSchema).min(1).max(100),
+  nextCursor: z5.string().regex(/^[1-9]\d*$/).nullable(),
   contentHash: HashSchema2
 }).strict().superRefine((page, context) => {
   const end = page.offset + page.tasks.length;
@@ -312,12 +364,12 @@ async function parseAndVerifyTrainingEvaluationTaskPage(value, expected) {
 }
 
 // src/training-grading-plan.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { compileBoundGraders, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
-var GradersSchema = z5.array(z5.object({ id: z5.string().trim().min(1) }).catchall(z5.unknown())).min(1).max(1e3);
-var RewardExecutionSchema = z5.object({
+var GradersSchema = z6.array(z6.object({ id: z6.string().trim().min(1) }).catchall(z6.unknown())).min(1).max(1e3);
+var RewardExecutionSchema = z6.object({
   binding: RewardBindingSchema,
-  rewards: z5.array(RewardReleaseSchema).min(1).max(100)
+  rewards: z6.array(RewardReleaseSchema).min(1).max(100)
 }).strict();
 async function deterministicTrainingRewardSource(input) {
   const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
@@ -334,23 +386,23 @@ async function deterministicTrainingRewardSource(input) {
 }
 
 // src/training-evaluation-source.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var TRAINING_EVALUATION_SOURCE_PATH = "evaluation-source.json";
-var TaskIdentitySchema = z6.object({
-  id: z6.string().trim().min(1),
-  clusterKey: z6.string().trim().min(1),
-  split: z6.enum(["train", "validation", "frozen_eval"])
+var TaskIdentitySchema = z7.object({
+  id: z7.string().trim().min(1),
+  clusterKey: z7.string().trim().min(1),
+  split: z7.enum(["train", "validation", "frozen_eval"])
 }).passthrough();
-var TrainingEvaluationSourceSchema = z6.object({
-  schemaVersion: z6.literal("openpond.trainingEvaluationSource.v1"),
+var TrainingEvaluationSourceSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingEvaluationSource.v1"),
   taskset: ModelProjectVersionedRefSchema,
-  tasks: z6.array(TaskIdentitySchema).min(1).max(1e4),
-  assets: z6.array(z6.object({
-    path: z6.string().trim().min(1).max(2e3),
-    sha256: z6.string().regex(/^[a-f0-9]{64}$/),
-    sizeBytes: z6.number().int().nonnegative(),
-    encoding: z6.literal("base64"),
-    content: z6.string().max(32 * 1024 * 1024)
+  tasks: z7.array(TaskIdentitySchema).min(1).max(1e4),
+  assets: z7.array(z7.object({
+    path: z7.string().trim().min(1).max(2e3),
+    sha256: z7.string().regex(/^[a-f0-9]{64}$/),
+    sizeBytes: z7.number().int().nonnegative(),
+    encoding: z7.literal("base64"),
+    content: z7.string().max(32 * 1024 * 1024)
   }).strict()).max(1e4)
 }).strict().superRefine((source, context) => {
   const ids = /* @__PURE__ */ new Set();
@@ -361,8 +413,8 @@ var TrainingEvaluationSourceSchema = z6.object({
   });
 });
 function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
-  const training = z6.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
-  const evaluation = z6.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
+  const training = z7.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
+  const evaluation = z7.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
   const trainIds = /* @__PURE__ */ new Set();
   const trainFamilies = /* @__PURE__ */ new Set();
   for (const task of training) {
@@ -388,24 +440,24 @@ async function trainingEvaluationSourceRef(input) {
 }
 
 // src/training.ts
-var IdSchema3 = z7.string().trim().min(1).max(500);
-var HashSchema3 = z7.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z7.string().datetime({ offset: true });
-var TrainingInputArtifactUploadSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingInputArtifactUpload.v2"),
-  kind: z7.enum(["portable_training_bundle", "reward_model_dataset"]),
-  idempotencyKey: z7.string().trim().min(1).max(500),
+var IdSchema3 = z8.string().trim().min(1).max(500);
+var HashSchema3 = z8.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema = z8.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z8.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z8.string().trim().min(1).max(500),
   sourceManifest: ModelProjectImmutableRefSchema,
-  payload: z7.unknown(),
+  payload: z8.unknown(),
   contentHash: HashSchema3
 }).strict();
-var TrainingInputArtifactSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingInputArtifact.v2"),
-  kind: z7.enum(["portable_training_bundle", "reward_model_dataset"]),
+var TrainingInputArtifactSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingInputArtifact.v2"),
+  kind: z8.enum(["portable_training_bundle", "reward_model_dataset"]),
   sourceManifest: ModelProjectImmutableRefSchema,
-  artifactRef: z7.string().trim().min(1).max(2e3),
+  artifactRef: z8.string().trim().min(1).max(2e3),
   contentHash: HashSchema3,
-  sizeBytes: z7.number().int().positive(),
+  sizeBytes: z8.number().int().positive(),
   createdAt: TimestampSchema
 }).strict();
 async function trainingInputArtifactUploadHash(upload) {
@@ -428,11 +480,11 @@ async function parseAndVerifyTrainingInputArtifactUpload(value) {
   }
   return parsed;
 }
-var TrainingJobKindSchema = z7.enum([
+var TrainingJobKindSchema = z8.enum([
   "reward_model_train",
   "policy_optimize"
 ]);
-var TrainingJobStateSchema = z7.enum([
+var TrainingJobStateSchema = z8.enum([
   "queued",
   "admitting",
   "provisioning",
@@ -443,91 +495,91 @@ var TrainingJobStateSchema = z7.enum([
   "failed",
   "cancelled"
 ]);
-var TrainingCapabilityRequirementSchema = z7.object({
+var TrainingCapabilityRequirementSchema = z8.object({
   id: IdSchema3,
-  version: z7.string().trim().min(1).max(200).nullable().default(null),
-  required: z7.boolean().default(true)
+  version: z8.string().trim().min(1).max(200).nullable().default(null),
+  required: z8.boolean().default(true)
 }).strict();
-var TrainingJobSourceSchema = z7.object({
-  modelProject: z7.object({
+var TrainingJobSourceSchema = z8.object({
+  modelProject: z8.object({
     id: IdSchema3,
     portableProjectId: IdSchema3,
-    revision: z7.number().int().positive(),
+    revision: z8.number().int().positive(),
     contentHash: HashSchema3
   }).strict(),
   harnessRunManifest: ModelProjectImmutableRefSchema,
   harnessRelease: ModelProjectImmutableRefSchema,
   taskset: ModelProjectVersionedRefSchema,
   tasksetRelease: ModelProjectImmutableRefSchema,
-  evaluation: z7.object({
+  evaluation: z8.object({
     taskset: ModelProjectVersionedRefSchema,
     dataset: ModelProjectImmutableRefSchema
   }).strict().nullable().optional(),
   dataset: ModelProjectImmutableRefSchema,
-  evidenceSets: z7.array(ModelProjectImmutableRefSchema).max(1e4)
+  evidenceSets: z8.array(ModelProjectImmutableRefSchema).max(1e4)
 }).strict();
-var RewardModelTrainingRequestSchema = z7.object({
-  kind: z7.literal("reward_model_train"),
+var RewardModelTrainingRequestSchema = z8.object({
+  kind: z8.literal("reward_model_train"),
   baseModel: ModelProjectBaseModelSchema,
   preferenceDatasetRelease: ModelProjectImmutableRefSchema,
   processorRelease: ModelProjectImmutableRefSchema,
-  recipe: z7.object({
-    schemaVersion: z7.literal("openpond.rewardModelRecipe.v1"),
-    method: z7.literal("reward_model"),
-    parameterization: z7.literal("lora_with_scalar_head")
-  }).catchall(z7.unknown())
+  recipe: z8.object({
+    schemaVersion: z8.literal("openpond.rewardModelRecipe.v1"),
+    method: z8.literal("reward_model"),
+    parameterization: z8.literal("lora_with_scalar_head")
+  }).catchall(z8.unknown())
 }).strict();
-var DeterministicRewardSourceSchema = z7.object({
-  kind: z7.literal("deterministic"),
+var DeterministicRewardSourceSchema = z8.object({
+  kind: z8.literal("deterministic"),
   grader: ModelProjectImmutableRefSchema,
   composer: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var LearnedRewardSourceSchema = z7.object({
-  kind: z7.literal("learned_reward"),
+var LearnedRewardSourceSchema = z8.object({
+  kind: z8.literal("learned_reward"),
   rewardModelVersion: ModelProjectImmutableRefSchema,
   qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
-  evaluationReferences: z7.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
-  scorerArtifact: z7.object({
-    artifactRef: z7.string().trim().min(1).max(2e3),
+  evaluationReferences: z8.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z8.object({
+    artifactRef: z8.string().trim().min(1).max(2e3),
     contentHash: HashSchema3,
     executionReceipt: ModelProjectImmutableRefSchema
   }).strict(),
   processorRelease: ModelProjectImmutableRefSchema,
   rewardComposerRelease: ModelProjectImmutableRefSchema
 }).strict();
-var PolicyOptimizationRequestSchema = z7.object({
-  kind: z7.literal("policy_optimize"),
+var PolicyOptimizationRequestSchema = z8.object({
+  kind: z8.literal("policy_optimize"),
   baseModel: ModelProjectBaseModelSchema,
   recipe: ModelProjectRecipeDocumentSchema,
-  rewardSource: z7.discriminatedUnion("kind", [
+  rewardSource: z8.discriminatedUnion("kind", [
     DeterministicRewardSourceSchema,
     LearnedRewardSourceSchema
   ]),
   resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
 }).strict();
-var TrainingJobRequestSchema = z7.discriminatedUnion("kind", [
+var TrainingJobRequestSchema = z8.discriminatedUnion("kind", [
   RewardModelTrainingRequestSchema,
   PolicyOptimizationRequestSchema
 ]);
-var TrainingJobApprovalSchema = z7.object({
+var TrainingJobApprovalSchema = z8.object({
   approvalHash: HashSchema3,
   approvedAt: TimestampSchema,
-  exportApproved: z7.boolean(),
-  maximumSpendUsd: z7.number().nonnegative(),
-  retentionDays: z7.number().int().nonnegative().nullable(),
-  region: z7.string().trim().min(1).max(200).nullable().default(null)
+  exportApproved: z8.boolean(),
+  maximumSpendUsd: z8.number().nonnegative(),
+  retentionDays: z8.number().int().nonnegative().nullable(),
+  region: z8.string().trim().min(1).max(200).nullable().default(null)
 }).strict();
-var TrainingJobSubmissionSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJobSubmission.v2"),
-  idempotencyKey: z7.string().trim().min(1).max(500),
-  name: z7.string().trim().min(1).max(200),
+var TrainingJobSubmissionSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z8.string().trim().min(1).max(500),
+  name: z8.string().trim().min(1).max(200),
   source: TrainingJobSourceSchema,
   job: TrainingJobRequestSchema,
-  requestedCapabilities: z7.array(TrainingCapabilityRequirementSchema).max(1e3),
-  placementObjective: z7.enum(["fast", "balanced", "economical"]),
-  budget: z7.object({
-    maximumSpendUsd: z7.number().nonnegative(),
-    maximumWallSeconds: z7.number().int().positive()
+  requestedCapabilities: z8.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z8.enum(["fast", "balanced", "economical"]),
+  budget: z8.object({
+    maximumSpendUsd: z8.number().nonnegative(),
+    maximumWallSeconds: z8.number().int().positive()
   }).strict(),
   approval: TrainingJobApprovalSchema,
   contentHash: HashSchema3
@@ -560,61 +612,61 @@ async function parseAndVerifyTrainingJobSubmission(value) {
   }
   return parsed;
 }
-var TrainingJobSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJob.v2"),
+var TrainingJobSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJob.v2"),
   id: IdSchema3,
   teamId: IdSchema3,
   kind: TrainingJobKindSchema,
   modelProjectId: IdSchema3,
   portableProjectId: IdSchema3,
-  sourceProjectRevision: z7.number().int().positive(),
+  sourceProjectRevision: z8.number().int().positive(),
   submissionHash: HashSchema3,
   state: TrainingJobStateSchema,
-  phase: z7.string().trim().min(1).max(200),
-  version: z7.number().int().nonnegative(),
-  progress: z7.number().min(0).max(1),
-  rolloutProgress: z7.object({
-    groupsCompleted: z7.number().int().nonnegative(),
-    groupsTarget: z7.number().int().nonnegative(),
-    optimizerUpdatesApplied: z7.number().int().nonnegative(),
-    optimizerUpdatesSkipped: z7.number().int().nonnegative()
+  phase: z8.string().trim().min(1).max(200),
+  version: z8.number().int().nonnegative(),
+  progress: z8.number().min(0).max(1),
+  rolloutProgress: z8.object({
+    groupsCompleted: z8.number().int().nonnegative(),
+    groupsTarget: z8.number().int().nonnegative(),
+    optimizerUpdatesApplied: z8.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z8.number().int().nonnegative()
   }).strict(),
-  accruedSpendUsd: z7.number().nonnegative(),
-  terminalReason: z7.string().trim().min(1).max(5e3).nullable(),
+  accruedSpendUsd: z8.number().nonnegative(),
+  terminalReason: z8.string().trim().min(1).max(5e3).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema,
   completedAt: TimestampSchema.nullable()
 }).strict();
-var TrainingJobPageSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJobPage.v2"),
-  jobs: z7.array(TrainingJobSchema).max(1e3),
-  nextCursor: z7.string().trim().min(1).max(2e3).nullable()
+var TrainingJobPageSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJobPage.v2"),
+  jobs: z8.array(TrainingJobSchema).max(1e3),
+  nextCursor: z8.string().trim().min(1).max(2e3).nullable()
 }).strict();
-var TrainingJobEventSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJobEvent.v2"),
+var TrainingJobEventSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJobEvent.v2"),
   id: IdSchema3,
   jobId: IdSchema3,
-  sequence: z7.number().int().nonnegative(),
+  sequence: z8.number().int().nonnegative(),
   type: IdSchema3,
-  phase: z7.string().trim().min(1).max(200),
-  message: z7.string().trim().min(1).max(5e3).nullable(),
-  data: z7.record(z7.string(), z7.unknown()).default({}),
+  phase: z8.string().trim().min(1).max(200),
+  message: z8.string().trim().min(1).max(5e3).nullable(),
+  data: z8.record(z8.string(), z8.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobLogSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJobLog.v2"),
+var TrainingJobLogSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJobLog.v2"),
   jobId: IdSchema3,
-  sequence: z7.number().int().nonnegative(),
-  level: z7.enum(["debug", "info", "warning", "error"]),
-  message: z7.string().max(2e4),
+  sequence: z8.number().int().nonnegative(),
+  level: z8.enum(["debug", "info", "warning", "error"]),
+  message: z8.string().max(2e4),
   createdAt: TimestampSchema
 }).strict();
-var TrainingJobControlRequestSchema = z7.object({ expectedVersion: z7.number().int().nonnegative() }).strict();
-var TrainingJobOutputSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJobOutput.v2"),
+var TrainingJobControlRequestSchema = z8.object({ expectedVersion: z8.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJobOutput.v2"),
   id: IdSchema3,
   jobId: IdSchema3,
-  kind: z7.enum([
+  kind: z8.enum([
     "checkpoint",
     "adapter",
     "scorer",
@@ -623,14 +675,14 @@ var TrainingJobOutputSchema = z7.object({
     "trace",
     "receipt"
   ]),
-  artifactRef: z7.string().trim().min(1).max(2e3),
+  artifactRef: z8.string().trim().min(1).max(2e3),
   contentHash: HashSchema3,
-  sizeBytes: z7.number().int().nonnegative(),
-  metadata: z7.record(z7.string(), z7.unknown()).default({}),
+  sizeBytes: z8.number().int().nonnegative(),
+  metadata: z8.record(z8.string(), z8.unknown()).default({}),
   createdAt: TimestampSchema
 }).strict();
-var TrainingExecutionReceiptSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingExecutionReceipt.v2"),
+var TrainingExecutionReceiptSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingExecutionReceipt.v2"),
   id: IdSchema3,
   teamId: IdSchema3,
   jobId: IdSchema3,
@@ -639,14 +691,14 @@ var TrainingExecutionReceiptSchema = z7.object({
   recipeHash: HashSchema3,
   capabilityHash: HashSchema3,
   runtimeRelease: ModelProjectImmutableRefSchema,
-  inputs: z7.array(ModelProjectImmutableRefSchema).max(1e4),
-  outputs: z7.array(ModelProjectImmutableRefSchema).max(1e4),
-  spendUsd: z7.number().nonnegative(),
-  durationSeconds: z7.number().nonnegative(),
-  cleanupComplete: z7.boolean(),
+  inputs: z8.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z8.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z8.number().nonnegative(),
+  durationSeconds: z8.number().nonnegative(),
+  cleanupComplete: z8.boolean(),
   issuer: IdSchema3,
   issuedAt: TimestampSchema,
-  signature: z7.string().trim().min(1).max(1e4).nullable()
+  signature: z8.string().trim().min(1).max(1e4).nullable()
 }).strict();
 async function trainingExecutionReceiptHash(receipt) {
   return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
@@ -682,18 +734,18 @@ async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
   }
   return receipt;
 }
-var TrainingJobOutputsSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingJobOutputs.v2"),
-  outputs: z7.array(TrainingJobOutputSchema).max(1e4),
+var TrainingJobOutputsSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z8.array(TrainingJobOutputSchema).max(1e4),
   receipt: TrainingExecutionReceiptSchema.nullable()
 }).strict();
-var TrainingApiErrorSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingApiError.v2"),
-  code: z7.string().trim().min(1).max(200),
-  message: z7.string().trim().min(1).max(5e3),
-  retryable: z7.boolean().default(false),
-  requestId: z7.string().trim().min(1).max(500).nullable().default(null),
-  details: z7.record(z7.string(), z7.unknown()).default({})
+var TrainingApiErrorSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingApiError.v2"),
+  code: z8.string().trim().min(1).max(200),
+  message: z8.string().trim().min(1).max(5e3),
+  retryable: z8.boolean().default(false),
+  requestId: z8.string().trim().min(1).max(500).nullable().default(null),
+  details: z8.record(z8.string(), z8.unknown()).default({})
 }).strict();
 var OpenPondTrainingApiError = class extends Error {
   status;
@@ -711,23 +763,23 @@ var OpenPondTrainingApiError = class extends Error {
     this.details = error.details;
   }
 };
-var TrainingCapabilitiesSchema = z7.object({
-  schemaVersion: z7.literal("openpond.trainingCapabilities.v2"),
+var TrainingCapabilitiesSchema = z8.object({
+  schemaVersion: z8.literal("openpond.trainingCapabilities.v2"),
   capabilityHash: HashSchema3,
-  jobKinds: z7.array(TrainingJobKindSchema),
-  methods: z7.array(z7.string().trim().min(1).max(200)),
-  placements: z7.array(
-    z7.enum(["local", "remote", "colocated", "provider_native"])
+  jobKinds: z8.array(TrainingJobKindSchema),
+  methods: z8.array(z8.string().trim().min(1).max(200)),
+  placements: z8.array(
+    z8.enum(["local", "remote", "colocated", "provider_native"])
   ),
-  controls: z7.object({
-    cancel: z7.boolean(),
-    stopAfterGroup: z7.boolean(),
-    resumeFromCheckpoint: z7.boolean()
+  controls: z8.object({
+    cancel: z8.boolean(),
+    stopAfterGroup: z8.boolean(),
+    resumeFromCheckpoint: z8.boolean()
   }).strict(),
-  limits: z7.object({
-    maximumSpendUsd: z7.number().nonnegative(),
-    maximumWallSeconds: z7.number().int().positive(),
-    maximumArtifactBytes: z7.number().int().positive()
+  limits: z8.object({
+    maximumSpendUsd: z8.number().nonnegative(),
+    maximumWallSeconds: z8.number().int().positive(),
+    maximumArtifactBytes: z8.number().int().positive()
   }).strict(),
   checkedAt: TimestampSchema,
   expiresAt: TimestampSchema
@@ -784,6 +836,7 @@ function createTrainingClient(input) {
   }
   return {
     ...createTrainingPreparationClient(request),
+    ...createTrainingAcceptanceClient(request),
     ...createTrainingHarnessSourceClient(request),
     ...createTrainingCandidateDecisionClient(request),
     async capabilities() {
@@ -821,12 +874,12 @@ function createTrainingClient(input) {
         parameters.set("modelProjectId", IdSchema3.parse(options.modelProjectId));
       }
       if (options.cursor) {
-        parameters.set("cursor", z7.string().trim().min(1).max(2e3).parse(options.cursor));
+        parameters.set("cursor", z8.string().trim().min(1).max(2e3).parse(options.cursor));
       }
       if (options.limit !== void 0) {
         parameters.set(
           "limit",
-          String(z7.number().int().min(1).max(1e3).parse(options.limit))
+          String(z8.number().int().min(1).max(1e3).parse(options.limit))
         );
       }
       const query = parameters.size > 0 ? `?${parameters.toString()}` : "";
@@ -867,7 +920,7 @@ function createTrainingClient(input) {
       );
     },
     async events(jobId) {
-      return z7.array(TrainingJobEventSchema).parse(
+      return z8.array(TrainingJobEventSchema).parse(
         unwrapObject(
           await request(
             `/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/events`
@@ -887,10 +940,10 @@ function createTrainingClient(input) {
       const id = IdSchema3.parse(jobId);
       const reference = ModelProjectImmutableRefSchema.parse(evaluation);
       const parameters = new URLSearchParams();
-      const cursor = options.cursor === void 0 ? void 0 : z7.string().regex(/^[1-9]\d*$/).parse(options.cursor);
-      const offset = cursor === void 0 ? 0 : z7.number().int().min(1).max(9999).parse(Number(cursor));
+      const cursor = options.cursor === void 0 ? void 0 : z8.string().regex(/^[1-9]\d*$/).parse(options.cursor);
+      const offset = cursor === void 0 ? 0 : z8.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(z7.number().int().min(1).max(100).parse(options.limit)));
+      if (options.limit !== void 0) parameters.set("limit", String(z8.number().int().min(1).max(100).parse(options.limit)));
       const query = parameters.size ? `?${parameters.toString()}` : "";
       return parseAndVerifyTrainingEvaluationTaskPage(
         await request(`/v1/training/jobs/${encodeURIComponent(id)}/evaluations/${encodeURIComponent(reference.id)}/tasks${query}`),
@@ -898,7 +951,7 @@ function createTrainingClient(input) {
       );
     },
     async logs(jobId) {
-      return z7.array(TrainingJobLogSchema).max(1e5).parse(
+      return z8.array(TrainingJobLogSchema).max(1e5).parse(
         unwrapObject(
           await request(
             `/v1/training/jobs/${encodeURIComponent(IdSchema3.parse(jobId))}/logs`
@@ -935,6 +988,10 @@ function trainingApiError(value, status) {
 }
 
 export {
+  TrainingAcceptanceGroupReferenceSchema,
+  TrainingAcceptanceGroupSummarySchema,
+  TrainingAcceptanceGroupPageSchema,
+  TrainingAcceptanceGroupQuerySchema,
   TrainingPreparationRequestSchema,
   TrainingPreparationPlanContentSchema,
   TrainingPreparationPlanSchema,
@@ -987,4 +1044,4 @@ export {
   TrainingCapabilitiesSchema,
   createTrainingClient
 };
-//# sourceMappingURL=chunk-KIBRMKJQ.js.map
+//# sourceMappingURL=chunk-JCPLAIZL.js.map