openpond-sdk 0.2.4 → 0.2.5

package/TASKSETS.md

@@ -86,3 +86,33 @@ release/package hashes; Profile provenance makes these different identities.
 Persist the exact publication intent and immutable package before sending it.
 After an uncertain response, replay that intent before publishing later local
 edits, then merge the recovered hosted receipt without reverting those edits.
+
+## Revising an approved batch
+
+Browser editors import schemas and types from `openpond-sdk/model-batch-review`.
+Servers use `inspectModelBatchPackage` from `openpond-sdk/taskset-packages` to
+validate the complete package and return its definition, binding, evidence, and
+decisions without portable file bytes. The inspection includes the sealed package
+hash. Full package validation and compilation remain on the server.
+
+`ModelBatchReviewRequestSchema`, `findModelBatchReview`, and
+`beginModelBatchReview` define explicit editing of a Model's selected reviewed
+batch. The host runs these helpers inside its authorized workspace transaction,
+checks the Model revision and selected Taskset reference, and verifies that the
+supplied package belongs to that immutable selection. An operation ID identifies
+one exact request; retries return the original receipt, while changed requests
+with the same operation ID conflict.
+
+The request can change task instructions, schemas, inputs, evaluator-only context,
+expected answers, and the selected published Reward binding. The helper creates
+a new definition, Reward graph, enabled direct source, and evidence with parent
+references. Sources record the original Model, package, batch, and Reward binding
+in `reviewOrigin`. Original source credentials and admission decisions are never
+imported. Attempts receive new IDs so matching example/attempt IDs from different
+parent sources remain distinct.
+
+Previously approved targets become pending feedback proposals. Policy-visible
+task changes clear the observed response because that response was produced for
+the original task. New evidence needs fresh grading and review before sealing;
+the helper does not attach a batch or start training. A host must separately
+compare the Model revision when attaching the newly prepared batch.

package/dist/model-batch-review.js

@@ -0,0 +1,48 @@
+// src/model-batch-review-contracts.ts
+import { z } from "zod";
+import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceSchema, TaskEvidenceSchema, TaskFeedbackSchema, TaskDefinitionSchema, TaskAdmissionDecisionSchema } from "@openpond/evals/learning";
+import { RewardBindingSchema } from "@openpond/evals/rewards";
+var ReleaseIdSchema = LearningRevisionRefSchema.shape.id;
+var ModelBatchReviewInspectionSchema = z.object({
+  schemaVersion: z.literal("openpond.modelBatchReviewInspection.v1"),
+  packageHash: z.string().regex(/^[a-f0-9]{64}$/),
+  definition: TaskDefinitionSchema,
+  binding: RewardBindingSchema,
+  evidence: z.array(TaskEvidenceSchema).min(1).max(1e4),
+  decisions: z.array(TaskAdmissionDecisionSchema).min(1).max(1e4)
+}).strict();
+var ModelBatchReviewRequestSchema = z.object({
+  schemaVersion: z.literal("openpond.modelBatchReviewRequest.v1"),
+  operationId: ReleaseIdSchema,
+  modelId: ReleaseIdSchema,
+  expectedModelRevision: z.number().int().positive(),
+  tasksetRef: LearningRevisionRefSchema,
+  rewardBindingRef: LearningRevisionRefSchema.nullable(),
+  definition: z.object({
+    name: z.string().trim().min(1).max(500).optional(),
+    instructions: z.string().trim().min(1).max(2e4).optional(),
+    inputSchema: LearningJsonObjectSchema.optional(),
+    outputSchema: LearningJsonObjectSchema.optional()
+  }).strict(),
+  examples: z.array(z.object({
+    evidence: LearningRevisionRefSchema,
+    input: LearningJsonObjectSchema.optional(),
+    expected: LearningJsonObjectSchema.nullable().optional(),
+    evaluatorContext: LearningJsonObjectSchema.nullable().optional(),
+    proposedTarget: LearningJsonObjectSchema.nullable().optional()
+  }).strict()).max(1e4)
+}).strict();
+var ModelBatchReviewReceiptSchema = z.object({
+  schemaVersion: z.literal("openpond.modelBatchReviewReceipt.v1"),
+  operationId: ReleaseIdSchema,
+  modelId: ReleaseIdSchema,
+  source: LearningSourceSchema,
+  evidence: z.array(TaskEvidenceSchema).min(1).max(1e4),
+  proposals: z.array(TaskFeedbackSchema).max(1e4)
+}).strict();
+export {
+  ModelBatchReviewInspectionSchema,
+  ModelBatchReviewReceiptSchema,
+  ModelBatchReviewRequestSchema
+};
+//# sourceMappingURL=model-batch-review.js.map

package/dist/model-batch-review.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/model-batch-review-contracts.ts"],
+  "sourcesContent": ["import { z } from \"zod\";\nimport { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceSchema, TaskEvidenceSchema, TaskFeedbackSchema, TaskDefinitionSchema, TaskAdmissionDecisionSchema } from \"@openpond/evals/learning\";\nimport { RewardBindingSchema } from \"@openpond/evals/rewards\";\n// Reuse the canonical release ID already exposed by Evals without bundling a\n// second copy of Harness's schema graph into the browser contract entrypoint.\nconst ReleaseIdSchema = LearningRevisionRefSchema.shape.id;\n\n/** Editor data from a server-validated package; excludes portable file bytes. */\nexport const ModelBatchReviewInspectionSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelBatchReviewInspection.v1\"),\n  packageHash: z.string().regex(/^[a-f0-9]{64}$/),\n  definition: TaskDefinitionSchema,\n  binding: RewardBindingSchema,\n  evidence: z.array(TaskEvidenceSchema).min(1).max(10_000),\n  decisions: z.array(TaskAdmissionDecisionSchema).min(1).max(10_000),\n}).strict();\nexport type ModelBatchReviewInspection = z.infer<typeof ModelBatchReviewInspectionSchema>;\n\nexport const ModelBatchReviewRequestSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelBatchReviewRequest.v1\"),\n  operationId: ReleaseIdSchema,\n  modelId: ReleaseIdSchema,\n  expectedModelRevision: z.number().int().positive(),\n  tasksetRef: LearningRevisionRefSchema,\n  rewardBindingRef: LearningRevisionRefSchema.nullable(),\n  definition: z.object({\n    name: z.string().trim().min(1).max(500).optional(),\n    instructions: z.string().trim().min(1).max(20_000).optional(),\n    inputSchema: LearningJsonObjectSchema.optional(),\n    outputSchema: LearningJsonObjectSchema.optional(),\n  }).strict(),\n  examples: z.array(z.object({\n    evidence: LearningRevisionRefSchema,\n    input: LearningJsonObjectSchema.optional(),\n    expected: LearningJsonObjectSchema.nullable().optional(),\n    evaluatorContext: LearningJsonObjectSchema.nullable().optional(),\n    proposedTarget: LearningJsonObjectSchema.nullable().optional(),\n  }).strict()).max(10_000),\n}).strict();\nexport type ModelBatchReviewRequest = z.infer<typeof ModelBatchReviewRequestSchema>;\n\n/** These are editable evidence and unapproved proposals, never admissions. */\nexport const ModelBatchReviewReceiptSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelBatchReviewReceipt.v1\"),\n  operationId: ReleaseIdSchema,\n  modelId: ReleaseIdSchema,\n  source: LearningSourceSchema,\n  evidence: z.array(TaskEvidenceSchema).min(1).max(10_000),\n  proposals: z.array(TaskFeedbackSchema).max(10_000),\n}).strict();\nexport type ModelBatchReviewReceipt = z.infer<typeof ModelBatchReviewReceiptSchema>;\n"],
+  "mappings": ";AAAA,SAAS,SAAS;AAClB,SAAS,0BAA0B,2BAA2B,sBAAsB,oBAAoB,oBAAoB,sBAAsB,mCAAmC;AACrL,SAAS,2BAA2B;AAGpC,IAAM,kBAAkB,0BAA0B,MAAM;AAGjD,IAAM,mCAAmC,EAAE,OAAO;AAAA,EACvD,eAAe,EAAE,QAAQ,wCAAwC;AAAA,EACjE,aAAa,EAAE,OAAO,EAAE,MAAM,gBAAgB;AAAA,EAC9C,YAAY;AAAA,EACZ,SAAS;AAAA,EACT,UAAU,EAAE,MAAM,kBAAkB,EAAE,IAAI,CAAC,EAAE,IAAI,GAAM;AAAA,EACvD,WAAW,EAAE,MAAM,2BAA2B,EAAE,IAAI,CAAC,EAAE,IAAI,GAAM;AACnE,CAAC,EAAE,OAAO;AAGH,IAAM,gCAAgC,EAAE,OAAO;AAAA,EACpD,eAAe,EAAE,QAAQ,qCAAqC;AAAA,EAC9D,aAAa;AAAA,EACb,SAAS;AAAA,EACT,uBAAuB,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;AAAA,EACjD,YAAY;AAAA,EACZ,kBAAkB,0BAA0B,SAAS;AAAA,EACrD,YAAY,EAAE,OAAO;AAAA,IACnB,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAS;AAAA,IACjD,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAM,EAAE,SAAS;AAAA,IAC5D,aAAa,yBAAyB,SAAS;AAAA,IAC/C,cAAc,yBAAyB,SAAS;AAAA,EAClD,CAAC,EAAE,OAAO;AAAA,EACV,UAAU,EAAE,MAAM,EAAE,OAAO;AAAA,IACzB,UAAU;AAAA,IACV,OAAO,yBAAyB,SAAS;AAAA,IACzC,UAAU,yBAAyB,SAAS,EAAE,SAAS;AAAA,IACvD,kBAAkB,yBAAyB,SAAS,EAAE,SAAS;AAAA,IAC/D,gBAAgB,yBAAyB,SAAS,EAAE,SAAS;AAAA,EAC/D,CAAC,EAAE,OAAO,CAAC,EAAE,IAAI,GAAM;AACzB,CAAC,EAAE,OAAO;AAIH,IAAM,gCAAgC,EAAE,OAAO;AAAA,EACpD,eAAe,EAAE,QAAQ,qCAAqC;AAAA,EAC9D,aAAa;AAAA,EACb,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,UAAU,EAAE,MAAM,kBAAkB,EAAE,IAAI,CAAC,EAAE,IAAI,GAAM;AAAA,EACvD,WAAW,EAAE,MAAM,kBAAkB,EAAE,IAAI,GAAM;AACnD,CAAC,EAAE,OAAO;",
+  "names": []
+}

package/dist/taskset-packages.js

@@ -2864,8 +2864,296 @@ var OpenPondTasksetPackageClient = class {
     return payload;
   }
 };
+
+// src/model-batch-review.ts
+import {
+  LearningDomainError as LearningDomainError2,
+  learningRef as learningRef6,
+  sameLearningRef as sameLearningRef4,
+  requireLearningRelease,
+  requireLearningResource,
+  taskBatchPackageMetadata as taskBatchPackageMetadata4
+} from "@openpond/evals/learning";
+
+// src/model-batch-review-contracts.ts
+import { z as z20 } from "zod";
+import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceSchema as LearningSourceSchema2, TaskEvidenceSchema as TaskEvidenceSchema2, TaskFeedbackSchema, TaskDefinitionSchema as TaskDefinitionSchema2, TaskAdmissionDecisionSchema as TaskAdmissionDecisionSchema2 } from "@openpond/evals/learning";
+import { RewardBindingSchema as RewardBindingSchema2 } from "@openpond/evals/rewards";
+var ReleaseIdSchema2 = LearningRevisionRefSchema.shape.id;
+var ModelBatchReviewInspectionSchema = z20.object({
+  schemaVersion: z20.literal("openpond.modelBatchReviewInspection.v1"),
+  packageHash: z20.string().regex(/^[a-f0-9]{64}$/),
+  definition: TaskDefinitionSchema2,
+  binding: RewardBindingSchema2,
+  evidence: z20.array(TaskEvidenceSchema2).min(1).max(1e4),
+  decisions: z20.array(TaskAdmissionDecisionSchema2).min(1).max(1e4)
+}).strict();
+var ModelBatchReviewRequestSchema = z20.object({
+  schemaVersion: z20.literal("openpond.modelBatchReviewRequest.v1"),
+  operationId: ReleaseIdSchema2,
+  modelId: ReleaseIdSchema2,
+  expectedModelRevision: z20.number().int().positive(),
+  tasksetRef: LearningRevisionRefSchema,
+  rewardBindingRef: LearningRevisionRefSchema.nullable(),
+  definition: z20.object({
+    name: z20.string().trim().min(1).max(500).optional(),
+    instructions: z20.string().trim().min(1).max(2e4).optional(),
+    inputSchema: LearningJsonObjectSchema.optional(),
+    outputSchema: LearningJsonObjectSchema.optional()
+  }).strict(),
+  examples: z20.array(z20.object({
+    evidence: LearningRevisionRefSchema,
+    input: LearningJsonObjectSchema.optional(),
+    expected: LearningJsonObjectSchema.nullable().optional(),
+    evaluatorContext: LearningJsonObjectSchema.nullable().optional(),
+    proposedTarget: LearningJsonObjectSchema.nullable().optional()
+  }).strict()).max(1e4)
+}).strict();
+var ModelBatchReviewReceiptSchema = z20.object({
+  schemaVersion: z20.literal("openpond.modelBatchReviewReceipt.v1"),
+  operationId: ReleaseIdSchema2,
+  modelId: ReleaseIdSchema2,
+  source: LearningSourceSchema2,
+  evidence: z20.array(TaskEvidenceSchema2).min(1).max(1e4),
+  proposals: z20.array(TaskFeedbackSchema).max(1e4)
+}).strict();
+
+// src/model-batch-review-preparation.ts
+import {
+  LearningDomainError,
+  LearningSourceSchema as LearningSourceSchema3,
+  TaskDefinitionSchema as TaskDefinitionSchema3,
+  TaskEvidenceSchema as TaskEvidenceSchema3,
+  TaskFeedbackSchema as TaskFeedbackSchema2,
+  assertLearningContentHash as assertLearningContentHash3,
+  learningEvidenceId,
+  learningRef as learningRef5,
+  sameLearningRef as sameLearningRef3,
+  sealLearningContent as sealLearningContent4,
+  taskBatchPackageMetadata as taskBatchPackageMetadata3,
+  verifyLearningTextAsset as verifyLearningTextAsset5
+} from "@openpond/evals/learning";
+import { compileBoundGraders as compileBoundGraders2, createRewardBinding, createRewardRelease, resolveBoundRewards } from "@openpond/evals/rewards";
+function prepareModelBatchReview(input) {
+  const { request, package: value } = input;
+  const learning = value.learningResources;
+  if (!learning) throw new LearningDomainError("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata3(value.taskset);
+  const id = `model-review-${contentHash([input.scope, request.modelId, request.operationId])}`;
+  const edits = new Map(request.examples.map((edit) => [contentHash(edit.evidence), edit]));
+  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef5(evidence2))));
+  const decisions = new Map(learning.decisions.map((decision) => [contentHash(decision.evidence), decision]));
+  if (edits.size !== request.examples.length || request.examples.some((edit) => !parentRefs.has(contentHash(edit.evidence)))) {
+    throw new LearningDomainError("model_review_evidence_mismatch", 409);
+  }
+  for (const resource of [input.binding, ...input.rewards, ...input.assets]) assertLearningContentHash3(resource);
+  resolveBoundRewards(input.binding, input.rewards);
+  const rewardByHash = /* @__PURE__ */ new Map();
+  for (const source2 of input.binding.sources) {
+    const original = input.rewards.find((reward) => sameLearningRef3(learningRef5(reward), source2.reward));
+    const { contentHash: _hash, ...content } = original;
+    rewardByHash.set(original.contentHash, createRewardRelease({ ...content, id: `${id}-reward-${original.contentHash}`, revision: 1 }));
+  }
+  const rewards = [...rewardByHash.values()];
+  const { contentHash: _bindingHash, recipeRef: _recipe, ...bindingContent } = input.binding;
+  const binding = createRewardBinding({
+    ...bindingContent,
+    id: `${id}-binding`,
+    revision: 1,
+    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef5(rewardByHash.get(source2.reward.contentHash)) }))
+  }, rewards);
+  const assetRefs = rewards.flatMap((reward) => [
+    ...reward.assets,
+    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
+    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]);
+  const assets = [...new Map(assetRefs.map((ref) => {
+    const asset = input.assets.find((asset2) => asset2.id === ref.id);
+    if (!asset) throw new LearningDomainError("model_review_reward_asset_missing", 422);
+    verifyLearningTextAsset5(asset, ref);
+    if (ref.visibility === "policy") throw new LearningDomainError("reward_asset_visibility_invalid", 422);
+    return [asset.id, asset];
+  })).values()];
+  const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
+  const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
+  const definition = TaskDefinitionSchema3.parse(sealLearningContent4({
+    ...definitionContent,
+    ...request.definition,
+    id: `${id}-definition`,
+    revision: 1,
+    rewardBinding: learningRef5(binding),
+    execution: {
+      ...execution,
+      policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders2(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
+    }
+  }));
+  const source = LearningSourceSchema3.parse(sealLearningContent4({
+    schemaVersion: "openpond.learningSource.v1",
+    id,
+    revision: 1,
+    name: `${definition.name} review`,
+    kind: "direct",
+    taskDefinition: learningRef5(definition),
+    enabled: true,
+    allowedSplits: [...new Set(learning.evidence.map((item) => item.submission.split))],
+    mapping: null,
+    adapterVersion: null,
+    reviewOrigin: {
+      modelId: request.modelId,
+      packageHash: value.contentHash,
+      taskset: learningRef5(value.taskset),
+      batch: learningRef5(learning.batch),
+      rewardBinding: learningRef5(input.binding)
+    }
+  }));
+  const evidence = learning.evidence.map((parent) => {
+    const edit = edits.get(contentHash(learningRef5(parent)));
+    const attemptId = `review-${parent.contentHash}`;
+    const policyChanged = contentHash({
+      instructions: definition.instructions,
+      inputSchema: definition.inputSchema,
+      outputSchema: definition.outputSchema,
+      input: edit?.input ?? parent.submission.input
+    }) !== contentHash({
+      instructions: metadata.definition.instructions,
+      inputSchema: metadata.definition.inputSchema,
+      outputSchema: metadata.definition.outputSchema,
+      input: parent.submission.input
+    });
+    return TaskEvidenceSchema3.parse(sealLearningContent4({
+      schemaVersion: "openpond.taskEvidence.v1",
+      id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
+      revision: 1,
+      source: learningRef5(source),
+      submission: {
+        ...parent.submission,
+        sourceId: source.id,
+        taskDefinition: learningRef5(definition),
+        attemptId,
+        // The old response was observed under the old policy-visible task. Its
+        // parent snapshot remains available, but it is not a run of new inputs.
+        observedOutput: policyChanged ? null : parent.submission.observedOutput,
+        idempotencyKey: `${id}-${parent.contentHash}`,
+        ...edit?.input === void 0 ? {} : { input: edit.input },
+        ...edit?.expected === void 0 ? {} : { expected: edit.expected },
+        ...edit?.evaluatorContext === void 0 ? {} : { evaluatorContext: edit.evaluatorContext }
+      },
+      supersedes: learningRef5(parent),
+      correctionFeedbackId: null,
+      receivedAt: input.now
+    }));
+  });
+  const proposals = evidence.flatMap((item) => {
+    const edit = edits.get(contentHash(item.supersedes));
+    const decision = decisions.get(contentHash(item.supersedes));
+    const target = edit?.proposedTarget === void 0 ? decision.approvedTarget : edit.proposedTarget;
+    return target === null ? [] : [TaskFeedbackSchema2.parse({
+      schemaVersion: "openpond.taskFeedbackRecord.v1",
+      id: `feedback-${contentHash([id, item.id])}`,
+      revision: 1,
+      submission: {
+        schemaVersion: "openpond.taskFeedback.v1",
+        sourceId: source.id,
+        idempotencyKey: `${id}-${item.id}`,
+        exampleId: item.submission.exampleId,
+        attemptId: item.submission.attemptId,
+        expectedEvidenceHash: item.contentHash,
+        occurredAt: input.now,
+        kind: "target_correction",
+        value: target,
+        note: "Proposed target for the revised task. Grade and review before admission."
+      },
+      status: "pending_review",
+      evidence: learningRef5(item),
+      createdAt: input.now,
+      review: null
+    })];
+  });
+  return { source, definition, binding, rewards, assets, evidence, proposals };
+}
+
+// src/model-batch-review.ts
+import { LearningDomainError as LearningDomainError3 } from "@openpond/evals/learning";
+var operation = (request) => `model-batch-review-${contentHash([request.modelId, request.operationId])}`;
+function inspectModelBatchPackage(raw) {
+  const value = validateTasksetPackage(raw);
+  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata4(value.taskset);
+  return ModelBatchReviewInspectionSchema.parse({
+    schemaVersion: "openpond.modelBatchReviewInspection.v1",
+    packageHash: value.contentHash,
+    definition: metadata.definition,
+    binding: metadata.binding,
+    evidence: value.learningResources.evidence,
+    decisions: value.learningResources.decisions
+  });
+}
+async function findModelBatchReview(transaction, raw) {
+  const request = ModelBatchReviewRequestSchema.parse(raw);
+  const prior = await transaction.operation(operation(request));
+  if (!prior) return null;
+  if (prior.requestHash !== contentHash(request)) throw new LearningDomainError2("learning_idempotency_conflict", 409);
+  return readReceipt(transaction, request, prior.resources);
+}
+async function beginModelBatchReview(transaction, input) {
+  const request = ModelBatchReviewRequestSchema.parse(input.request);
+  const prior = await findModelBatchReview(transaction, request);
+  if (prior) return prior;
+  const value = validateTasksetPackage(input.package);
+  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata4(value.taskset);
+  const selected = request.rewardBindingRef;
+  const retained = !selected || sameLearningRef4(selected, learningRef6(metadata.binding));
+  const binding = retained ? metadata.binding : await requireLearningRelease(transaction, "binding", selected);
+  const rewards = retained ? metadata.rewards : await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
+  const assetIds = new Set(rewards.flatMap((reward) => [
+    ...reward.assets,
+    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
+    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]).map((asset) => asset.id));
+  const assets = retained ? value.learningResources.assets : await Promise.all([...assetIds].map((id) => requireLearningResource(transaction, "asset", id, 1)));
+  const prepared = prepareModelBatchReview({ ...input, request, package: value, binding, rewards, assets });
+  const pointers = [];
+  for (const asset of prepared.assets) {
+    const existing = await transaction.get("asset", asset.id, 1);
+    if (existing && existing.contentHash !== asset.contentHash) throw new LearningDomainError2("model_review_asset_conflict", 409);
+    if (!existing) await transaction.put("asset", asset, 0);
+  }
+  for (const reward of prepared.rewards) await transaction.put("reward", reward, 0);
+  await transaction.put("binding", prepared.binding, 0);
+  await transaction.put("definition", prepared.definition, 0);
+  await transaction.put("source", prepared.source, 0, { parentId: request.modelId });
+  pointers.push({ kind: "source", id: prepared.source.id, revision: 1 });
+  for (const evidence of prepared.evidence) {
+    await transaction.put("evidence", evidence, 0, { parentId: prepared.source.id });
+    pointers.push({ kind: "evidence", id: evidence.id, revision: 1 });
+  }
+  for (const proposal of prepared.proposals) {
+    await transaction.put("feedback", proposal, 0, { parentId: proposal.evidence.id, status: proposal.status });
+    pointers.push({ kind: "feedback", id: proposal.id, revision: 1 });
+  }
+  await transaction.saveOperation(operation(request), { requestHash: contentHash(request), resources: pointers });
+  return readReceipt(transaction, request, pointers);
+}
+async function readReceipt(transaction, request, pointers) {
+  const resources = await Promise.all(pointers.map((pointer) => requireLearningResource(transaction, pointer.kind, pointer.id, pointer.revision)));
+  return ModelBatchReviewReceiptSchema.parse({
+    schemaVersion: "openpond.modelBatchReviewReceipt.v1",
+    operationId: request.operationId,
+    modelId: request.modelId,
+    source: resources.find((resource) => resource.schemaVersion === "openpond.learningSource.v1"),
+    evidence: resources.filter((resource) => resource.schemaVersion === "openpond.taskEvidence.v1"),
+    proposals: resources.filter((resource) => resource.schemaVersion === "openpond.taskFeedbackRecord.v1")
+  });
+}
 export {
   MAX_TASKSET_PACKAGE_BYTES,
+  LearningDomainError3 as ModelBatchReviewError,
+  ModelBatchReviewInspectionSchema,
+  ModelBatchReviewReceiptSchema,
+  ModelBatchReviewRequestSchema,
   OpenPondTasksetPackageClient,
   OpenPondTasksetPackageError,
   TasksetPackageContentSchema,
@@ -2876,8 +3164,11 @@ export {
   TasksetPackageReadbackSchema,
   TasksetPackageReceiptSchema,
   TasksetPackageSchema,
+  beginModelBatchReview,
   createTasksetPackage,
   decodeTasksetPackageFile,
+  findModelBatchReview,
+  inspectModelBatchPackage,
   learningPackageContextFiles,
   tasksetPackageRewardBinding,
   validateTasksetLearningResources,