openpond-sdk 0.11.6 → 0.12.1

package/dist/dataset-workspaces.js

@@ -1,8 +1,9 @@
 import {
   TaskDesignProposalSchema
-} from "./chunk-2NBI5UOK.js";
+} from "./chunk-WVISXXIL.js";
 import {
   ConnectedCaseRefSchema,
+  ConnectedStartingAssetSchema,
   DatasetWorkspaceBeginVersionSchema,
   DatasetWorkspaceListQuerySchema,
   DatasetWorkspaceListSchema,
@@ -11,32 +12,35 @@ import {
   DatasetWorkspaceValidationSchema,
   DatasetWorkspaceVersionsSchema,
   DatasetWorkspaceWriteSchema
-} from "./chunk-ILXO64IV.js";
+} from "./chunk-7GYXC2AI.js";
 import {
   compileTasksetDraftWorkspace
-} from "./chunk-NFLEPINR.js";
+} from "./chunk-VSRTJDVB.js";
 import {
   TasksetDraftSchema,
   createTasksetDraft,
   createTasksetDraftFile,
   createTasksetDraftWorkspace,
   decodeTasksetDraftFileContent,
+  decodeTasksetDraftWorkspaceFile,
   validateTasksetDraftWorkspace
-} from "./chunk-NA7PNRQZ.js";
+} from "./chunk-WNH4DOEC.js";
 import {
   TasksetCatalogReleaseRefSchema
 } from "./chunk-K3JCP4FO.js";
-import "./chunk-IPWCUGDN.js";
-import "./chunk-IS3P4OOW.js";
+import "./chunk-ROBAX5TN.js";
+import "./chunk-7AZDNZP6.js";
 import {
   TaskDataRecordSchema,
+  TaskRequiredOutputSchema,
+  TasksetEnvironmentContractSchema,
   TasksetSourceRefSchema
-} from "./chunk-OLHLJ2X3.js";
+} from "./chunk-FHCSDXIA.js";
 import "./chunk-2U54EOXJ.js";
-import "./chunk-TTAFUUHZ.js";
+import "./chunk-YVFERCUC.js";
 import "./chunk-OEPYLZXK.js";
 import "./chunk-YSKUXQ2N.js";
-import "./chunk-KV6JXPQH.js";
+import "./chunk-DUKW3R7O.js";
 import "./chunk-KAE7AMYE.js";
 import {
   ExperimentGraderPinSchema
@@ -156,6 +160,7 @@ var DatasetPreparationPolicySchema = z2.object({
     modelId: Id,
     maximumOutputTokens: z2.number().int().min(1).max(32768)
   }).strict(),
+  adjudicator: z2.object({ modelId: Id, maximumOutputTokens: z2.number().int().min(1).max(32768) }).strict(),
   grading: z2.discriminatedUnion("mode", [
     z2.object({ mode: z2.literal("auto") }).strict(),
     z2.object({ mode: z2.literal("existing_only") }).strict(),
@@ -372,6 +377,7 @@ var PreparedTaskProvenanceSchema = z2.object({
   firstAvailableAt: Timestamp,
   initialInputHash: Hash,
   initialEnvironmentHash: Hash,
+  initialAssetsHash: Hash.nullable(),
   sourceScopeHash: Hash
 }).strict().superRefine((value, ctx) => {
   if (!value.sourceSpans.some((span) => span.role === "requirement"))
@@ -953,15 +959,104 @@ var DatasetPreparationResearchDecisionSchema = z5.object({
   contextSummary: z5.string().max(2e4)
 }).strict();
 
+// src/dataset-preparation-starting-state.ts
+import { z as z6 } from "zod";
+var Hash3 = z6.string().regex(/^[a-f0-9]{64}$/);
+function connectedStartingAssetReference(receiptId, path) {
+  if (!/^starting-assets-[a-f0-9]{40}$/.test(receiptId)) throw new Error("Invalid starting asset receipt.");
+  ConnectedStartingAssetSchema.shape.path.parse(path);
+  return `starting-assets:${receiptId}#${encodeURIComponent(path)}`;
+}
+function parseConnectedStartingAssetReference(reference) {
+  const match = /^starting-assets:(starting-assets-[a-f0-9]{40})#(.+)$/.exec(reference);
+  if (!match) throw new Error("Invalid starting asset reference.");
+  const path = decodeURIComponent(match[2]);
+  if (connectedStartingAssetReference(match[1], path) !== reference) throw new Error("Noncanonical starting asset reference.");
+  return { receiptId: match[1], path };
+}
+var PreparedRepositoryStartingStateSchema = z6.object({
+  schemaVersion: z6.literal("openpond.preparedRepositoryStartingState.v1"),
+  dependencyClosureQualified: z6.literal(false),
+  assets: z6.array(ConnectedStartingAssetSchema.extend({
+    receiptId: z6.string().regex(/^starting-assets-[a-f0-9]{40}$/),
+    receiptHash: Hash3,
+    source: ConnectedCaseRefSchema
+  }).strict()).min(1).max(100)
+}).strict().superRefine((value, ctx) => {
+  if (new Set(value.assets.map((asset) => asset.path)).size !== value.assets.length)
+    ctx.addIssue({ code: "custom", message: "Starting paths must be distinct." });
+  if (value.assets.some((asset) => asset.commitHash !== value.assets[0].commitHash || contentHash(asset.source) !== contentHash(value.assets[0].source)))
+    ctx.addIssue({ code: "custom", message: "Starting assets must belong to one original task boundary and commit." });
+});
+function preparedRepositoryEnvironment() {
+  return TasksetEnvironmentContractSchema.parse({
+    protocolVersion: "openpond.taskEnvironment.v1",
+    kind: "work",
+    entrypoint: "openpond-work-v1",
+    stateful: true,
+    deterministicSeeds: true,
+    toolNames: ["work_exec", "work_save_output"],
+    lifecycle: ["create", "reset", "step", "grade", "cleanup"],
+    defaultTimeoutMs: 3e5,
+    networkPolicy: "none",
+    resources: [],
+    metadata: {
+      requiredOutputs: [{
+        path: "changes.patch",
+        mediaType: "text/x-diff",
+        maxBytes: 5e6,
+        metadata: {
+          protocol: "openpond.preparedRepositoryPatch.v1",
+          baseDirectory: "starting-state",
+          description: "Save a unified diff against the retained starting files, with original repository-relative paths."
+        }
+      }],
+      maxInputBytes: 15 * 1024 * 1024
+    }
+  });
+}
+
 // src/dataset-preparation-workspace.ts
 function createPreparedTaskAuthoringWorkspace(input) {
   const provenance = PreparedTaskProvenanceSchema.parse(input.provenance);
   const proposal = TaskDesignProposalSchema.parse(input.proposal);
-  const sources = input.sources.map((source) => TasksetSourceRefSchema.parse(source));
+  let sources = input.sources.map((source) => TasksetSourceRefSchema.parse(source));
   const environment = TasksetDraftSchema.shape.environment.parse(input.initialEnvironment);
+  const startingFiles = input.startingFiles ?? [];
+  let workAssets;
+  let retainedFiles = startingFiles;
   if (contentHash(input.initialInput) !== provenance.initialInputHash || contentHash(environment) !== provenance.initialEnvironmentHash)
     throw new Error("Prepared Taskset input or starting environment differs from its reconstruction.");
-  if (environment.kind !== "chat" || environment.stateful || environment.toolNames.length || (environment.resources?.length ?? 0) || proposal.taskKind !== "chat" || proposal.diagnosis.requiredTools.length)
+  if (environment.kind === "work") {
+    const state = PreparedRepositoryStartingStateSchema.parse(input.startingAssets);
+    if (contentHash(state) !== provenance.initialAssetsHash) throw new Error("Prepared starting assets differ from their reconstruction.");
+    if (contentHash(preparedRepositoryEnvironment()) !== contentHash(environment) || proposal.taskKind !== "single_agent" || proposal.diagnosis.requiredTools.some((tool) => !environment.toolNames.includes(tool)))
+      throw new Error("Repository preparation requires its fixed isolated Work protocol.");
+    if (startingFiles.length !== state.assets.length || new Set(startingFiles.map((file) => file.path)).size !== startingFiles.length)
+      throw new Error("Prepared starting files differ from the retained inventory.");
+    for (const asset of state.assets) {
+      const file = startingFiles.find((file2) => file2.path === `assets/starting-state/${asset.path}`);
+      if (!file || file.contentHash !== asset.sha256 || file.sizeBytes !== asset.sizeBytes)
+        throw new Error("Prepared starting files differ from the retained inventory.");
+      decodeTasksetDraftWorkspaceFile(file);
+    }
+    for (const asset of state.assets) if (!sources.some((source) => "kind" in source && source.kind === "connected_activity" && source.id === asset.source.id && source.sourceHash === asset.source.snapshotHash))
+      throw new Error("Prepared starting files require their exact connected source revision.");
+    sources = sources.map((source) => "kind" in source && source.kind === "connected_activity" ? { ...source, sourceFileHashes: [...new Set(state.assets.filter((asset) => asset.source.id === source.id).map((asset) => asset.sha256))] } : source);
+    workAssets = state.assets.map((asset) => ({
+      id: `starting-file-${contentHash(asset.path).slice(0, 40)}`,
+      sourceRefId: asset.source.id,
+      artifactRef: `assets/${provenance.candidateId}/starting-state/${asset.path}`,
+      fileName: asset.path.split("/").at(-1),
+      stagingPath: `starting-state/${asset.path}`,
+      mediaType: "application/octet-stream",
+      sha256: asset.sha256,
+      sizeBytes: asset.sizeBytes,
+      split: "validation",
+      metadata: { receiptId: asset.receiptId, receiptHash: asset.receiptHash, originalPath: asset.path, mode: asset.mode }
+    }));
+    retainedFiles = startingFiles.map((file) => ({ ...file, path: file.path.replace("assets/starting-state/", `assets/${provenance.candidateId}/starting-state/`) }));
+  } else if (environment.kind !== "chat" || environment.stateful || environment.toolNames.length || (environment.resources?.length ?? 0) || proposal.taskKind !== "chat" || proposal.diagnosis.requiredTools.length || startingFiles.length || input.startingAssets || provenance.initialAssetsHash !== null)
     throw new Error("Text preparation cannot silently add tools, state or starting assets.");
   const sourceIds = new Set(sources.map((source) => source.id));
   if (!sources.length || sourceIds.size !== sources.length || proposal.sourceIds.some((id) => !sourceIds.has(id)) || proposal.proposedExamples.length !== 1 || proposal.proposedExamples.some((example) => !sourceIds.has(example.sourceId)))
@@ -970,8 +1065,8 @@ function createPreparedTaskAuthoringWorkspace(input) {
     throw new Error("Prepared Taskset authoring provenance is invalid.");
   if (!proposal.proposedGraders.length || new Set(proposal.proposedGraders.map((grader) => grader.id)).size !== proposal.proposedGraders.length)
     throw new Error("Prepared Taskset needs distinct outcome graders.");
-  if (proposal.generatedFiles.some((file) => file.role === "environment"))
-    throw new Error("Generated code cannot replace the fixed initial text environment.");
+  if (proposal.generatedFiles.some((file) => file.role === "environment" || file.path === "assets" || file.path.startsWith("assets/")))
+    throw new Error("Generated code cannot replace the fixed initial environment or starting files.");
   if (proposal.graderFixtures.some((fixture) => fixture.taskIndex !== 0 || fixture.metadata.substituteExpectedOutput === true))
     throw new Error("Prepared fixtures cannot refer to another task or substitute a historical answer.");
   const draft = createTasksetDraft({
@@ -985,12 +1080,13 @@ function createPreparedTaskAuthoringWorkspace(input) {
   draft.environment = environment;
   draft.graders = proposal.proposedGraders.map((grader) => ({
     ...grader,
+    taskIds: [provenance.candidateId],
     privileged: true,
     ...grader.kind === "model_judge" ? { rewardEligible: false, calibrationStatus: "pending" } : {},
-    metadata: { ...grader.metadata, preparedTask: provenance.candidateId, authoringSkillHash: input.skillHash }
+    metadata: { ...grader.metadata, preparedRewardEligible: grader.rewardEligible, preparedTask: provenance.candidateId, authoringSkillHash: input.skillHash }
   }));
   draft.policy = {
-    policyVisibleFields: ["input"],
+    policyVisibleFields: environment.kind === "work" ? ["input", "requiredOutputs"] : ["input"],
     privilegedFields: ["expectedOutput"],
     hiddenGraderRefs: draft.graders.map((grader) => grader.id),
     connectedAppScopes: []
@@ -1005,8 +1101,33 @@ function createPreparedTaskAuthoringWorkspace(input) {
     policyVisibleContext: {},
     privilegedContextRef: null,
     sourceRefs: [...sourceIds],
+    ...environment.kind === "work" ? {
+      assets: workAssets,
+      requiredOutputs: TaskRequiredOutputSchema.array().min(1).max(100).parse(environment.metadata.requiredOutputs)
+    } : {},
     tags: ["prepared-task", "development-exposed"],
-    metadata: { preparedTask: provenance, qualificationStatus: "pending" }
+    metadata: {
+      preparedTask: provenance,
+      qualificationStatus: "pending",
+      ...workAssets ? { portableTaskRecord: {
+        id: provenance.candidateId,
+        clusterKey: provenance.familyKey,
+        split: "validation",
+        input: input.initialInput,
+        expectedOutput: null,
+        policyVisibleContext: {},
+        privilegedContextRef: null,
+        artifactRefs: workAssets.map((asset) => ({
+          id: asset.id,
+          path: asset.artifactRef,
+          contentHash: asset.sha256,
+          sizeBytes: asset.sizeBytes,
+          mediaType: asset.mediaType,
+          visibility: "policy"
+        })),
+        tags: ["prepared-task", "development-exposed"]
+      } } : {}
+    }
   })];
   draft.graderFixtures = proposal.graderFixtures.map(({ taskIndex: _index, ...fixture }) => ({
     ...fixture,
@@ -1026,7 +1147,7 @@ function createPreparedTaskAuthoringWorkspace(input) {
   return createTasksetDraftWorkspace({
     schemaVersion: "openpond.tasksetDraftWorkspace.v1",
     draft,
-    files: proposal.generatedFiles.map((generated) => {
+    files: [...retainedFiles, ...proposal.generatedFiles.map((generated) => {
       const file = createTasksetDraftFile(generated.path, new TextEncoder().encode(generated.content));
       return {
         path: file.path,
@@ -1034,7 +1155,153 @@ function createPreparedTaskAuthoringWorkspace(input) {
         sizeBytes: file.sizeBytes,
         base64: Buffer.from(decodeTasksetDraftFileContent(file.content)).toString("base64")
       };
-    })
+    })]
+  });
+}
+
+// src/dataset-preparation-qualification-contracts.ts
+import { z as z7 } from "zod";
+var Id5 = z7.string().trim().min(1).max(240);
+var Text2 = z7.string().trim().min(1).max(2e4);
+var PreparedQualificationWitnessSchema = z7.object({
+  id: Id5,
+  label: z7.enum(["positive", "incorrect", "incomplete", "adversarial"]),
+  output: z7.record(z7.string(), z7.unknown()),
+  artifacts: z7.array(z7.object({
+    path: TaskRequiredOutputSchema.shape.path,
+    mediaType: TaskRequiredOutputSchema.shape.mediaType,
+    base64: z7.string().max(8 * 1024 * 1024)
+  }).strict()).max(100)
+}).strict().superRefine((value, ctx) => {
+  if (new Set(value.artifacts.map((artifact) => artifact.path)).size !== value.artifacts.length)
+    ctx.addIssue({ code: "custom", message: "Qualification artifacts must have distinct paths." });
+});
+var PreparedQualificationPlanSchema = z7.object({
+  schemaVersion: z7.literal("openpond.preparedQualificationPlan.v1"),
+  requirementRefs: z7.array(Id5).min(1).max(100),
+  supported: z7.boolean(),
+  limitations: z7.array(Text2).max(20),
+  independentVerifier: z7.object({
+    runtime: z7.enum(["isolated_javascript", "sandbox_process"]),
+    source: z7.string().trim().min(1).max(2e5),
+    exportName: z7.literal("verify"),
+    timeoutMs: z7.number().int().min(1).max(6e4)
+  }).strict().nullable(),
+  witnesses: z7.array(PreparedQualificationWitnessSchema).max(20)
+}).strict().superRefine((value, ctx) => {
+  if (new Set(value.requirementRefs).size !== value.requirementRefs.length || new Set(value.witnesses.map((item) => item.id)).size !== value.witnesses.length)
+    ctx.addIssue({ code: "custom", message: "Qualification evidence identities must be distinct." });
+  if (value.supported && (!value.independentVerifier || value.limitations.length || ["positive", "incorrect", "incomplete", "adversarial"].some((label) => !value.witnesses.some((witness) => witness.label === label))))
+    ctx.addIssue({ code: "custom", message: "Supported qualification needs a complete verifier and witness population without unresolved evidence gaps." });
+});
+var PreparedWitnessAdjudicationSchema = z7.object({
+  schemaVersion: z7.literal("openpond.preparedWitnessAdjudication.v1"),
+  witnesses: z7.array(z7.object({
+    id: Id5,
+    failureMode: z7.enum(["none", "incorrect", "incomplete", "adversarial", "unverifiable"]),
+    requirements: z7.array(z7.object({ reference: Id5, status: z7.enum(["satisfied", "violated", "unverifiable"]), reason: Text2 }).strict()).min(1).max(100)
+  }).strict()).min(4).max(20)
+}).strict();
+var PreparedCheckerAuditSchema = z7.object({
+  schemaVersion: z7.literal("openpond.preparedCheckerAudit.v1"),
+  requirements: z7.array(z7.object({ reference: Id5, adequatelyChecked: z7.boolean(), oracleAdequatelyChecked: z7.boolean(), reason: Text2 }).strict()).min(1).max(100),
+  executionIsolationPassed: z7.boolean(),
+  futureEvidenceLeak: z7.boolean(),
+  unresolvedLimitations: z7.array(Text2).max(20),
+  passed: z7.boolean()
+}).strict();
+
+// src/dataset-preparation-assembly.ts
+function assemblePreparedTaskWorkspaces(input) {
+  const base = validateTasksetDraftWorkspace(input.base);
+  const candidates = input.candidates.map(validateTasksetDraftWorkspace);
+  if (!candidates.length || base.draft.status !== "draft" || candidates.some((workspace) => workspace.draft.profileId !== base.draft.profileId || workspace.draft.tasks.length !== 1))
+    throw new Error("Prepared assembly requires owned individual task workspaces and an editable destination.");
+  const environment = base.draft.tasks.length ? base.draft.environment : candidates[0].draft.environment;
+  if (candidates.some((workspace) => contentHash(workspace.draft.environment) !== contentHash(environment)))
+    throw new Error("Prepared tasks require separate versions for incompatible execution environments.");
+  const tasks = [...base.draft.tasks], files = [...base.files], graders = base.draft.graders.map((grader) => ({
+    ...grader,
+    ...grader.taskIds ? {} : { taskIds: base.draft.tasks.map((task) => task.id) }
+  }));
+  if (!base.draft.tasks.length && graders.length) throw new Error("Destination graders require their original task population.");
+  const sources = new Map(base.draft.sourceRefs.map((source) => [source.id, source]));
+  const fixtures = [...base.draft.graderFixtures];
+  const inventory = [...base.draft.metadata.portableFileInventory ?? []];
+  const candidateIds = [];
+  for (const workspace of candidates) {
+    const task = workspace.draft.tasks[0];
+    if (tasks.some((existing) => existing.id === task.id)) throw new Error("Prepared assembly repeats a task identity.");
+    const provenance = task.metadata.preparedTask;
+    if (provenance?.preparationId !== input.preparationId) throw new Error("Prepared task belongs to another run.");
+    const sourceIds = new Map(workspace.draft.sourceRefs.map((source) => [source.id, `prepared-source-${contentHash([task.id, source.id]).slice(0, 40)}`]));
+    candidateIds.push(task.id);
+    tasks.push({
+      ...task,
+      sourceRefs: task.sourceRefs.map((id) => sourceIds.get(id)),
+      ...task.assets ? { assets: task.assets.map((asset) => ({ ...asset, sourceRefId: sourceIds.get(asset.sourceRefId) })) } : {}
+    });
+    const namespace = `graders/${task.id}/`;
+    for (const file of workspace.files) files.push({ ...file, path: file.path.startsWith("assets/") ? file.path : namespace + file.path });
+    const graderIds = new Map(workspace.draft.graders.map((grader) => [grader.id, `prepared-grader-${contentHash([task.id, grader.id]).slice(0, 40)}`]));
+    for (const grader of workspace.draft.graders) {
+      const id = graderIds.get(grader.id);
+      graders.push({
+        ...grader,
+        id,
+        taskIds: [task.id],
+        ...grader.kind === "custom_verifier" ? { module: namespace + grader.module } : {},
+        metadata: { ...grader.metadata, preparedTask: task.id, composedFrom: { id: grader.id, contentHash: contentHash(grader) } }
+      });
+    }
+    for (const fixture of workspace.draft.graderFixtures) {
+      const projection = fixture.metadata.rewardCalibration;
+      if (projection) fixtures.push({ ...fixture, metadata: { ...fixture.metadata, rewardCalibration: {
+        ...projection,
+        graderId: graderIds.get(projection.graderId ?? projection.sourceReward.id)
+      } } });
+      else fixtures.push({ ...fixture, id: `prepared-fixture-${contentHash([task.id, fixture.id]).slice(0, 40)}` });
+    }
+    for (const entry of workspace.draft.metadata.portableFileInventory ?? []) inventory.push({
+      ...entry,
+      sourcePath: entry.sourcePath.startsWith("assets/") ? entry.sourcePath : namespace + entry.sourcePath
+    });
+    for (const source of workspace.draft.sourceRefs) sources.set(sourceIds.get(source.id), {
+      ...source,
+      id: sourceIds.get(source.id),
+      metadata: { ...source.metadata, assemblyOriginalSourceId: source.id }
+    });
+  }
+  const policyVisibleFields = [...new Set(candidates.flatMap((workspace) => workspace.draft.policy.policyVisibleFields).concat(base.draft.tasks.length ? base.draft.policy.policyVisibleFields : []))];
+  return createTasksetDraftWorkspace({
+    schemaVersion: base.schemaVersion,
+    files,
+    draft: {
+      ...base.draft,
+      name: base.draft.name.trim() || `Prepared ${candidates.length} tasks`,
+      objective: base.draft.objective.trim() || candidates.map((workspace) => workspace.draft.objective).join("\n").slice(0, 5e4),
+      revision: input.revision,
+      updatedAt: input.now,
+      environment,
+      tasks,
+      graders,
+      graderFixtures: fixtures,
+      sourceRefs: [...sources.values()],
+      policy: {
+        ...base.draft.policy,
+        policyVisibleFields,
+        privilegedFields: [.../* @__PURE__ */ new Set(["expectedOutput", ...base.draft.policy.privilegedFields])],
+        hiddenGraderRefs: graders.map((grader) => grader.id)
+      },
+      metadata: { ...base.draft.metadata, portableFileInventory: inventory, datasetPreparation: {
+        schemaVersion: "openpond.datasetPreparationAssembly.v1",
+        preparationId: input.preparationId,
+        candidateIds,
+        baseWorkspaceHash: base.contentHash,
+        authoredWorkspaceHashes: candidates.map((workspace) => workspace.contentHash),
+        qualification: "pending"
+      } }
+    }
   });
 }
 export {
@@ -1071,10 +1338,19 @@ export {
   OpenPondDatasetPopulationClient,
   OpenPondDatasetPreparationClient,
   OpenPondDatasetWorkspaceClient,
+  PreparedCheckerAuditSchema,
+  PreparedQualificationPlanSchema,
+  PreparedQualificationWitnessSchema,
+  PreparedRepositoryStartingStateSchema,
   PreparedTaskEvidenceSpanSchema,
   PreparedTaskProvenanceSchema,
   PreparedTaskQualificationSchema,
+  PreparedWitnessAdjudicationSchema,
+  assemblePreparedTaskWorkspaces,
   compileTasksetDraftWorkspace,
-  createPreparedTaskAuthoringWorkspace
+  connectedStartingAssetReference,
+  createPreparedTaskAuthoringWorkspace,
+  parseConnectedStartingAssetReference,
+  preparedRepositoryEnvironment
 };
 //# sourceMappingURL=dataset-workspaces.js.map