openpond-sdk 0.1.14 → 0.2.1

package/MODEL_STARTERS.md

@@ -37,6 +37,53 @@ Evidence references are nullable pointers to actual verifier, baseline, training
 
 The repository's invoice-extraction example authors 80 original synthetic text tasks and executes its verifier fixtures. Its baseline, training, evaluation and full product qualification remain pending. The local server includes preparation, atomic persistence and file-materialization adapters; catalog publication, route wiring and Desktop Get Started integration are separate delivery steps.
 
+## Model-owned Taskset revisions
+
+`deriveModelTaskset` compiles a new immutable Taskset from an exact source package
+and selected Reward binding. `ModelTasksetPackageSchema` and
+`validateModelTasksetPackage` validate task formats, private assets, executable
+graders, definition references and pinned execution resources. A package is
+independent of its catalog listing.
+
+```ts
+import { deriveModelTaskset } from "openpond-sdk/model-starters";
+
+const derived = deriveModelTaskset({
+  owner: { scopeId, modelId },
+  source,
+  rewardBinding: selectedBinding,
+  rewards: selectedRewards,
+  assets: resolvedPrivateAssets,
+});
+```
+
+The host must authorize the owner and source before compilation. The first edit
+creates a distinct model-owned identity; later edits to that owner's Taskset
+retain its identity and advance its revision. Another owner's edit forks a new
+identity. `metadata.modelTasksetDerivation` retains exact root and parent refs.
+The compiler rebuilds the grader snapshot, verifier set and task definition;
+it preserves task rows and the environment. Changed packages have no inherited
+calibration receipts, qualification results or publisher privacy attestation.
+Authored fixtures can be retained for checking again.
+
+The result includes `executionResources` for text and tool packages. Persist
+`createModelTasksetExecutionResourcesAsset(derived.executionResources)` with the
+derived package. On another host, load that private asset using
+`modelTasksetExecutionResourcesAssetId(taskset)` and validate it with
+`resolveModelTasksetExecutionResourcesAsset(taskset, asset)` before another edit.
+This preserves the exact environment and verifier set for text packages too. Tool
+packages also include the updated private JavaScript `execution` closure; persist
+`createModelStarterExecutionAsset(derived.execution)` with the new definition.
+The Taskset's binding and embedded Reward snapshot must agree. A model-level
+selection cannot override the published grader snapshot at execution time.
+
+Compilation changes no model or storage. The host must materialize immutable
+files first, then atomically commit the Taskset, dependencies, intended model
+attachment/configuration, compare-and-set revision and original operation
+receipt. Keep preparation state across uncertain outcomes. A lost model CAS
+may leave unattached package files; it must not retarget a model or overwrite an
+earlier package. Reusing an operation returns its original committed result.
+
 ## Hosted starter attempts
 
 The `openpond-sdk/model-starter-attempts` subpath defines a durable, workspace-scoped attempt API. Create requests select an attached Model Project, exact Taskset release, task, environment seed and explicit policy. They never carry replacement task input, private state, verifier source or evaluator context. Reuse the same `operationId` for a transport retry; use a new identity for a new evaluation.

package/dist/model-starter-catalog.js

@@ -1,5 +1,5 @@
 // src/model-starter-catalog.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // src/model-projects.ts
 import { z } from "zod";
@@ -195,11 +195,11 @@ var ModelProjectApiErrorSchema = z.object({
 }).strict();
 
 // src/model-starters.ts
-import { z as z3 } from "zod";
-import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
-import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent2 } from "@openpond/evals/learning";
-import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
-import { assertBoundedTaskJson as assertBoundedTaskJson3, validateTaskValue } from "@openpond/evals/task-schema";
+import { z as z5 } from "zod";
+import { TasksetReleaseSchema as TasksetReleaseSchema2, assertTasksetRelease as assertTasksetRelease2 } from "@openpond/evals/tasksets";
+import { LearningTextAssetSchema as LearningTextAssetSchema2, TaskDefinitionSchema as TaskDefinitionSchema2, learningRef as learningRef3, sameLearningRef as sameLearningRef2, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
+import { RewardBindingSchema as RewardBindingSchema2, RewardReleaseSchema as RewardReleaseSchema2, compileBoundGraders as compileBoundGraders2 } from "@openpond/evals/rewards";
+import { assertBoundedTaskJson as assertBoundedTaskJson3, validateTaskValue as validateTaskValue2 } from "@openpond/evals/task-schema";
 
 // src/model-starter-execution.ts
 import { z as z2 } from "zod";
@@ -270,29 +270,61 @@ function validateModelStarterExecution(execution, taskset, assets) {
   }
 }
 
+// src/model-taskset-derivation.ts
+import { z as z4 } from "zod";
+import { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease as verifyEnvironmentRelease2, verifyVerifierSetRelease as verifyVerifierSetRelease2 } from "@openpond/evals";
+import { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
+import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
+import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
+import { validateTaskValue } from "@openpond/evals/task-schema";
+
+// src/model-taskset-resources.ts
+import { z as z3 } from "zod";
+import { EnvironmentReleaseSchema as EnvironmentReleaseSchema2, VerifierSetReleaseSchema as VerifierSetReleaseSchema2, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
+import { createLearningTextAsset as createLearningTextAsset2, sealLearningContent as sealLearningContent2, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+var ModelTasksetExecutionResourcesSchema = z3.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
+
+// src/model-taskset-derivation.ts
+var OwnerSchema = z4.object({ scopeId: z4.string().trim().min(1).max(500), modelId: z4.string().trim().min(1).max(500) }).strict();
+var ModelTasksetDerivationSchema = z4.object({
+  schemaVersion: z4.literal("openpond.modelTasksetDerivation.v1"),
+  owner: OwnerSchema,
+  root: ModelProjectVersionedRefSchema,
+  parent: ModelProjectVersionedRefSchema
+}).strict();
+var ModelTasksetPackageSchema = z4.object({
+  taskset: TasksetReleaseSchema,
+  taskDefinition: TaskDefinitionSchema,
+  rewardBinding: RewardBindingSchema,
+  rewards: z4.array(RewardReleaseSchema).min(1).max(100),
+  assets: z4.array(LearningTextAssetSchema).max(1e3),
+  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
+  execution: ModelStarterExecutionSchema.optional()
+}).strict();
+
 // src/model-starters.ts
-var IdSchema2 = z3.string().trim().min(1).max(500);
+var IdSchema2 = z5.string().trim().min(1).max(500);
 var RefSchema = ModelProjectVersionedRefSchema;
-var ModelStarterContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.modelStarter.v1"),
+var ModelStarterContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.modelStarter.v1"),
   id: IdSchema2,
-  revision: z3.number().int().positive(),
-  name: z3.string().trim().min(1).max(200),
-  description: z3.string().trim().min(1).max(2e3),
-  category: z3.enum(["extraction", "support", "operations", "knowledge", "coding", "writing", "classification"]),
+  revision: z5.number().int().positive(),
+  name: z5.string().trim().min(1).max(200),
+  description: z5.string().trim().min(1).max(2e3),
+  category: z5.enum(["extraction", "support", "operations", "knowledge", "coding", "writing", "classification"]),
   taskset: RefSchema,
   taskDefinition: RefSchema,
   rewardBinding: RefSchema,
-  rewards: z3.array(RefSchema).min(1).max(100),
-  assets: z3.array(RefSchema).max(1e3),
-  previewTaskIds: z3.array(IdSchema2).min(1).max(8),
+  rewards: z5.array(RefSchema).min(1).max(100),
+  assets: z5.array(RefSchema).max(1e3),
+  previewTaskIds: z5.array(IdSchema2).min(1).max(8),
   startingModel: ModelProjectBaseModelSchema,
-  supportedMethods: z3.array(ModelProjectTrainingMethodSchema).min(1).max(8),
+  supportedMethods: z5.array(ModelProjectTrainingMethodSchema).min(1).max(8),
   defaultMethod: ModelProjectTrainingMethodSchema,
-  provenance: z3.object({ author: z3.string().min(1).max(200), license: z3.string().min(1).max(200), sourceDescription: z3.string().min(1).max(2e3) }).strict(),
+  provenance: z5.object({ author: z5.string().min(1).max(200), license: z5.string().min(1).max(200), sourceDescription: z5.string().min(1).max(2e3) }).strict(),
   // These are references to real results. Package publication does not create
   // evidence, qualify a starter, or enable continuous learning.
-  evidence: z3.object({ verifierFixtures: RefSchema.nullable(), baseline: RefSchema.nullable(), training: RefSchema.nullable(), evaluation: RefSchema.nullable() }).strict()
+  evidence: z5.object({ verifierFixtures: RefSchema.nullable(), baseline: RefSchema.nullable(), training: RefSchema.nullable(), evaluation: RefSchema.nullable() }).strict()
 }).strict().superRefine((starter, context) => {
   if (!starter.supportedMethods.includes(starter.defaultMethod)) context.addIssue({ code: "custom", path: ["defaultMethod"], message: "The default method must be supported by the package." });
   for (const field of ["rewards", "assets"]) {
@@ -300,23 +332,23 @@ var ModelStarterContentSchema = z3.object({
   }
   if (new Set(starter.previewTaskIds).size !== starter.previewTaskIds.length) context.addIssue({ code: "custom", path: ["previewTaskIds"], message: "Preview tasks must be unique." });
 });
-var ModelStarterSchema = ModelStarterContentSchema.safeExtend({ contentHash: z3.string().regex(/^[a-f0-9]{64}$/) });
-var ResolvedModelStarterSchema = z3.object({
+var ModelStarterSchema = ModelStarterContentSchema.safeExtend({ contentHash: z5.string().regex(/^[a-f0-9]{64}$/) });
+var ResolvedModelStarterSchema = z5.object({
   starter: ModelStarterSchema,
-  taskset: TasksetReleaseSchema,
-  taskDefinition: TaskDefinitionSchema,
-  rewardBinding: RewardBindingSchema,
-  rewards: z3.array(RewardReleaseSchema).min(1).max(100),
-  assets: z3.array(LearningTextAssetSchema).max(1e3),
+  taskset: TasksetReleaseSchema2,
+  taskDefinition: TaskDefinitionSchema2,
+  rewardBinding: RewardBindingSchema2,
+  rewards: z5.array(RewardReleaseSchema2).min(1).max(100),
+  assets: z5.array(LearningTextAssetSchema2).max(1e3),
   execution: ModelStarterExecutionSchema.optional()
 }).strict();
-var ModelStarterPrivacyReviewSchema = z3.object({
-  schemaVersion: z3.literal("openpond.modelStarterPrivacyReview.v1"),
-  disposition: z3.literal("synthetic_only"),
-  reviewedBy: z3.string().trim().min(1).max(500),
-  reviewedAt: z3.iso.datetime(),
-  reviewedContentHash: z3.string().regex(/^[a-f0-9]{64}$/),
-  note: z3.string().trim().min(1).max(2e3)
+var ModelStarterPrivacyReviewSchema = z5.object({
+  schemaVersion: z5.literal("openpond.modelStarterPrivacyReview.v1"),
+  disposition: z5.literal("synthetic_only"),
+  reviewedBy: z5.string().trim().min(1).max(500),
+  reviewedAt: z5.iso.datetime(),
+  reviewedContentHash: z5.string().regex(/^[a-f0-9]{64}$/),
+  note: z5.string().trim().min(1).max(2e3)
 }).strict();
 function modelStarterPrivacyContentHash(value) {
   const { contentHash: _starterHash, ...starter } = value.starter;
@@ -328,19 +360,19 @@ function modelStarterPrivacyContentHash(value) {
     const { privacyReview: _review, ...content } = authoring;
     metadata.starterAuthoring = content;
   }
-  return sealLearningContent2({ ...value, starter: { ...starter, taskset: tasksetRef }, taskset: { ...taskset, metadata } }).contentHash;
+  return sealLearningContent4({ ...value, starter: { ...starter, taskset: tasksetRef }, taskset: { ...taskset, metadata } }).contentHash;
 }
-var ModelStarterCreationIntentSchema = z3.object({
+var ModelStarterCreationIntentSchema = z5.object({
   profileId: IdSchema2,
   modelId: IdSchema2,
-  name: z3.string().trim().min(1).max(200),
+  name: z5.string().trim().min(1).max(200),
   starter: RefSchema,
   startingModel: ModelProjectBaseModelSchema,
   method: ModelProjectTrainingMethodSchema,
   rewardBindingRef: RefSchema.nullable().optional()
 }).strict();
 var ModelStarterCreationRequestSchema = ModelStarterCreationIntentSchema.extend({
-  schemaVersion: z3.literal("openpond.modelStarterCreation.v1"),
+  schemaVersion: z5.literal("openpond.modelStarterCreation.v1"),
   operationId: IdSchema2
 }).strict();
 function validateResolvedModelStarter(value) {
@@ -355,12 +387,12 @@ function validateResolvedModelStarter(value) {
   const resources = [starter, taskset, taskDefinition, rewardBinding, ...rewards, ...assets];
   for (const resource of resources) {
     const { contentHash, ...content } = resource;
-    if (sealLearningContent2(content).contentHash !== contentHash) throw new Error(`Starter resource integrity failed: ${resource.id}.`);
+    if (sealLearningContent4(content).contentHash !== contentHash) throw new Error(`Starter resource integrity failed: ${resource.id}.`);
   }
-  assertTasksetRelease(taskset);
+  assertTasksetRelease2(taskset);
   validateModelStarterExecution(resolved.execution, taskset, assets);
   function exact(expected, resource) {
-    if (!sameLearningRef(expected, learningRef2(resource))) throw new Error(`Starter dependency mismatch: ${expected.id}.`);
+    if (!sameLearningRef2(expected, learningRef3(resource))) throw new Error(`Starter dependency mismatch: ${expected.id}.`);
   }
   exact(starter.taskset, taskset);
   exact(starter.taskDefinition, taskDefinition);
@@ -369,8 +401,8 @@ function validateResolvedModelStarter(value) {
   if (rewardBinding.recipeRef) throw new Error("Starter binding recipes must be resolved into a standalone binding before publication.");
   const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
   const execution = { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} };
-  if (sealLearningContent2(execution).contentHash !== sealLearningContent2(taskDefinition.execution).contentHash) throw new Error("Starter execution context differs from its task format.");
-  if (sealLearningContent2({ graders: taskset.graders }).contentHash !== sealLearningContent2({ graders: compileBoundGraders(rewardBinding, rewards) }).contentHash) throw new Error("Starter executable graders differ from its Reward binding.");
+  if (sealLearningContent4(execution).contentHash !== sealLearningContent4(taskDefinition.execution).contentHash) throw new Error("Starter execution context differs from its task format.");
+  if (sealLearningContent4({ graders: taskset.graders }).contentHash !== sealLearningContent4({ graders: compileBoundGraders2(rewardBinding, rewards) }).contentHash) throw new Error("Starter executable graders differ from its Reward binding.");
   for (const [references, values] of [[starter.rewards, rewards], [starter.assets, assets]]) {
     if (references.length !== values.length || new Set(values.map((resource) => resource.id)).size !== values.length) throw new Error("Starter dependency inventory mismatch.");
     for (const ref of references) {
@@ -394,7 +426,7 @@ function validateResolvedModelStarter(value) {
     ];
     for (const ref of references) {
       const asset = assets.find((asset2) => asset2.id === ref.id);
-      if (!asset || sealLearningContent2(asset.asset).contentHash !== sealLearningContent2(ref).contentHash) throw new Error(`Starter Reward source is missing or changed: ${ref.id}.`);
+      if (!asset || sealLearningContent4(asset.asset).contentHash !== sealLearningContent4(ref).contentHash) throw new Error(`Starter Reward source is missing or changed: ${ref.id}.`);
       if (ref.visibility === "policy") throw new Error(`Starter Reward source must remain private to its evaluator: ${ref.id}.`);
     }
   }
@@ -402,12 +434,12 @@ function validateResolvedModelStarter(value) {
   const inputSplits = /* @__PURE__ */ new Map();
   for (const task of taskset.tasks) {
     if (task.policyVisibleContext.instructions !== taskDefinition.instructions) throw new Error(`Starter task does not carry its declared model instructions: ${task.id}.`);
-    const inputHash = sealLearningContent2({ input: task.input, context: task.policyVisibleContext }).contentHash;
+    const inputHash = sealLearningContent4({ input: task.input, context: task.policyVisibleContext }).contentHash;
     const priorSplit = inputSplits.get(inputHash);
     if (priorSplit && priorSplit !== task.split) throw new Error("Starter policy input appears in multiple splits.");
     inputSplits.set(inputHash, task.split);
-    if (!validateTaskValue(taskDefinition.inputSchema, task.input).valid) throw new Error(`Starter task input does not match its format: ${task.id}.`);
-    if (task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Starter expected output does not match its format: ${task.id}.`);
+    if (!validateTaskValue2(taskDefinition.inputSchema, task.input).valid) throw new Error(`Starter task input does not match its format: ${task.id}.`);
+    if (task.expectedOutput !== null && !validateTaskValue2(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Starter expected output does not match its format: ${task.id}.`);
   }
   for (const id of starter.previewTaskIds) {
     const task = taskset.tasks.find((task2) => task2.id === id);
@@ -417,18 +449,18 @@ function validateResolvedModelStarter(value) {
 }
 
 // src/model-starter-catalog.ts
-var ModelStarterCatalogQuerySchema = z4.object({
-  afterId: z4.string().trim().min(1).max(500).optional(),
-  limit: z4.number().int().min(1).max(100).default(30)
+var ModelStarterCatalogQuerySchema = z6.object({
+  afterId: z6.string().trim().min(1).max(500).optional(),
+  limit: z6.number().int().min(1).max(100).default(30)
 }).strict();
 var ModelStarterCatalogItemSchema = ModelStarterSchema.extend({
-  rewardSummary: z4.array(z4.object({ name: z4.string().min(1).max(500), kind: z4.enum(["custom_verifier", "model_judge", "human", "learned_model", "content", "schema", "artifact", "runtime_event", "state"]) }).strict()).max(100).optional()
+  rewardSummary: z6.array(z6.object({ name: z6.string().min(1).max(500), kind: z6.enum(["custom_verifier", "model_judge", "human", "learned_model", "content", "schema", "artifact", "runtime_event", "state"]) }).strict()).max(100).optional()
 });
-var ModelStarterCatalogPageSchema = z4.object({
-  items: z4.array(ModelStarterCatalogItemSchema).max(100),
-  nextCursor: z4.string().min(1).max(500).nullable()
+var ModelStarterCatalogPageSchema = z6.object({
+  items: z6.array(ModelStarterCatalogItemSchema).max(100),
+  nextCursor: z6.string().min(1).max(500).nullable()
 }).strict();
-var ModelStarterCatalogErrorSchema = z4.object({ code: z4.string().min(1).max(200), message: z4.string().min(1).max(5e3) }).strict();
+var ModelStarterCatalogErrorSchema = z6.object({ code: z6.string().min(1).max(200), message: z6.string().min(1).max(5e3) }).strict();
 var OpenPondModelStarterCatalogError = class extends Error {
   constructor(status, code, message) {
     super(message);