openpond-sdk 0.12.24 → 0.12.26

package/dist/dataset-workspaces.js

@@ -1,6 +1,6 @@
 import {
   TaskDesignProposalSchema
-} from "./chunk-QIGMNB6M.js";
+} from "./chunk-P56JWQYV.js";
 import {
   DatasetTaskAppendReceiptSchema,
   DatasetTaskAppendRequestSchema,
@@ -8,7 +8,7 @@ import {
   DatasetTaskInputSchema,
   addDatasetTask,
   createTaskAdder
-} from "./chunk-NZRGRUYG.js";
+} from "./chunk-MUG4OQKL.js";
 import {
   ConnectedCaseRefSchema,
   ConnectedStartingAssetSchema,
@@ -20,45 +20,50 @@ import {
   DatasetWorkspaceValidationSchema,
   DatasetWorkspaceVersionsSchema,
   DatasetWorkspaceWriteSchema
-} from "./chunk-AG6UJ3DI.js";
+} from "./chunk-57ROW3XF.js";
 import {
   compileTasksetDraftWorkspace
-} from "./chunk-BNBPKCIR.js";
+} from "./chunk-3BILL33A.js";
 import {
   createTasksetDraftFile,
   createTasksetDraftWorkspace,
   decodeTasksetDraftFileContent,
   decodeTasksetDraftWorkspaceFile,
   validateTasksetDraftWorkspace
-} from "./chunk-Q4RGCEOI.js";
+} from "./chunk-JINWKUKR.js";
 import "./chunk-GWXJSBWR.js";
 import {
   TasksetDraftSchema,
   createTasksetDraft
-} from "./chunk-GCUWJUUM.js";
+} from "./chunk-4A4FNG4R.js";
 import {
   TaskDataRecordSchema,
   TaskRequiredOutputSchema,
   TasksetEnvironmentContractSchema,
   TasksetSourceRefSchema
-} from "./chunk-ZQ6QTYRE.js";
+} from "./chunk-AQV7RQZH.js";
 import "./chunk-TK3DXH7A.js";
 import {
   TasksetCatalogReleaseRefSchema
-} from "./chunk-Z252BNAZ.js";
-import "./chunk-H3367ISL.js";
+} from "./chunk-VE5JD5FN.js";
 import "./chunk-QTNYXOJW.js";
+import "./chunk-H3367ISL.js";
 import {
   ExperimentGraderPinSchema
-} from "./chunk-GS5HEE4M.js";
-import "./chunk-ZRTNR4U7.js";
-import "./chunk-JMFYNIYZ.js";
-import "./chunk-MVAEE5EI.js";
+} from "./chunk-4REK5TTE.js";
+import "./chunk-XWUTYFOU.js";
+import "./chunk-CAOMKM55.js";
+import "./chunk-H5KHLBC5.js";
 import "./chunk-CL3IOOVL.js";
-import "./chunk-B3ZHJ2KK.js";
+import {
+  readBoundedJsonResponse
+} from "./chunk-B3ZHJ2KK.js";
 import {
   contentHash
 } from "./chunk-H3JZ3P5T.js";
+import {
+  DEFAULT_API_BASE_URL
+} from "./chunk-QYWPNNP3.js";
 import "./chunk-YLJ4XMA6.js";
 
 // src/dataset-workspace-operations.ts
@@ -550,7 +555,7 @@ var DatasetPreparationRequestError = class extends Error {
 var OpenPondDatasetPreparationClient = class {
   constructor(options) {
     this.options = options;
-    const url = new URL(options.baseUrl);
+    const url = new URL(options.baseUrl ?? DEFAULT_API_BASE_URL);
     if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim())
       throw new Error(
         "A clean API origin and workspace credentials are required."
@@ -757,11 +762,69 @@ var OpenPondDatasetPreparationClient = class {
   }
 };
 
+// src/dataset-workspace-error.ts
+import { z as z4 } from "zod";
+var Code = z4.enum([
+  "dataset_validation_failed",
+  "dataset_grader_invalid",
+  "dataset_grader_source_unavailable",
+  "dataset_feedback_key_conflict",
+  "dataset_request_invalid",
+  "dataset_request_failed",
+  "dataset_not_found",
+  "dataset_revision_conflict",
+  "dataset_operation_conflict",
+  "dataset_workspace_changed",
+  "dataset_validation_changed",
+  "dataset_source_context_immutable"
+]);
+var Failure = z4.object({
+  code: Code,
+  // Bound the expected wire field, but never retain or display its contents.
+  message: z4.string().max(5e3).optional()
+}).strict();
+var validationGuidance = {
+  dataset_validation_failed: "Dataset validation failed. Review source privacy and licensing checks, required approved demonstrations, and attached graders before validating the saved revision again.",
+  dataset_grader_invalid: "Dataset grader validation failed. Review the attached graders and their checked fixtures before validating again.",
+  dataset_grader_source_unavailable: "An attached grader release is unavailable or has changed. Select the intended published grader release before validating again.",
+  dataset_feedback_key_conflict: "Attached graders use conflicting feedback keys. Choose distinct published grader feedback keys before validating again."
+};
+var DatasetWorkspaceRequestError = class extends Error {
+  constructor(status, code = "dataset_request_failed") {
+    const safeCode = Code.safeParse(code);
+    const value = safeCode.success ? safeCode.data : "dataset_request_failed";
+    super((status === 422 ? validationGuidance[value] : void 0) ?? `Dataset request failed (${status}).`);
+    this.status = status;
+    this.name = "DatasetWorkspaceRequestError";
+    this.code = value;
+    this.retryable = status === 408 || status === 429 || status >= 500;
+    this.outcomeUnknown = status === 408 || status >= 500;
+  }
+  status;
+  code;
+  retryable;
+  outcomeUnknown;
+};
+async function readDatasetWorkspaceFailure(response) {
+  let code = "dataset_request_failed";
+  try {
+    const mediaType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+    if (mediaType === "application/json") {
+      const parsed = Failure.safeParse(await readBoundedJsonResponse(response, 16 * 1024, "Dataset failure"));
+      if (parsed.success) code = parsed.data.code;
+    } else {
+      await response.body?.cancel();
+    }
+  } catch {
+  }
+  return new DatasetWorkspaceRequestError(response.status, code);
+}
+
 // src/dataset-workspace-client.ts
 var OpenPondDatasetWorkspaceClient = class {
   constructor(options) {
     this.options = options;
-    const url = new URL(options.baseUrl);
+    const url = new URL(options.baseUrl ?? DEFAULT_API_BASE_URL);
     if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim())
       throw new Error("A clean API origin and workspace credentials are required.");
     this.baseUrl = url.toString().replace(/\/+$/, "");
@@ -919,7 +982,7 @@ var OpenPondDatasetWorkspaceClient = class {
         ...body === void 0 ? {} : { body: JSON.stringify(body) }
       }
     );
-    if (!response.ok) throw new Error(`Dataset request failed (${response.status}).`);
+    if (!response.ok) throw await readDatasetWorkspaceFailure(response);
     if (maxResponseBytes !== void 0) {
       if (!response.body) throw new Error("Dataset response is empty.");
       const reader = response.body.getReader(), chunks = [];
@@ -950,31 +1013,31 @@ var OpenPondDatasetWorkspaceClient = class {
 
 // src/dataset-population.ts
 import { TaskSplitSchema, TaskRecordSchema } from "@openpond/evals/tasksets";
-import { z as z4 } from "zod";
-var Id3 = z4.string().trim().min(1).max(500);
-var Hash2 = z4.string().regex(/^[a-f0-9]{64}$/);
-var DatasetPopulationQuerySchema = z4.object({
+import { z as z5 } from "zod";
+var Id3 = z5.string().trim().min(1).max(500);
+var Hash2 = z5.string().regex(/^[a-f0-9]{64}$/);
+var DatasetPopulationQuerySchema = z5.object({
   release: TasksetCatalogReleaseRefSchema,
   afterId: Id3.optional(),
-  limit: z4.number().int().min(1).max(1e4).default(100),
-  view: z4.enum(["ids", "policy"]).default("ids")
+  limit: z5.number().int().min(1).max(1e4).default(100),
+  view: z5.enum(["ids", "policy"]).default("ids")
 }).strict().superRefine((query, context) => {
   if (query.view === "policy" && query.limit > 100) context.addIssue({ code: "custom", path: ["limit"], message: "Policy previews are bounded to 100 tasks." });
 });
-var TaskIdentity = z4.object({ id: TaskRecordSchema.shape.id, split: TaskSplitSchema }).strict();
+var TaskIdentity = z5.object({ id: TaskRecordSchema.shape.id, split: TaskSplitSchema }).strict();
 var PolicyTask = TaskIdentity.extend({
-  input: z4.record(z4.string(), z4.unknown()),
-  policyVisibleContext: z4.record(z4.string(), z4.unknown()),
-  artifacts: z4.array(z4.object({ id: Id3, path: z4.string(), mediaType: z4.string(), sizeBytes: z4.number().int().nonnegative() }).strict()).max(1e3)
+  input: z5.record(z5.string(), z5.unknown()),
+  policyVisibleContext: z5.record(z5.string(), z5.unknown()),
+  artifacts: z5.array(z5.object({ id: Id3, path: z5.string(), mediaType: z5.string(), sizeBytes: z5.number().int().nonnegative() }).strict()).max(1e3)
 }).strict();
-var DatasetPopulationPageSchema = z4.object({
-  schemaVersion: z4.literal("openpond.datasetPopulationPage.v1"),
+var DatasetPopulationPageSchema = z5.object({
+  schemaVersion: z5.literal("openpond.datasetPopulationPage.v1"),
   teamId: Id3,
   release: TasksetCatalogReleaseRefSchema,
   view: DatasetPopulationQuerySchema.shape.view,
-  taskCount: z4.number().int().nonnegative(),
-  items: z4.array(z4.union([TaskIdentity, PolicyTask])).max(1e4),
-  graders: z4.array(ExperimentGraderPinSchema).max(1e3),
+  taskCount: z5.number().int().nonnegative(),
+  items: z5.array(z5.union([TaskIdentity, PolicyTask])).max(1e4),
+  graders: z5.array(ExperimentGraderPinSchema).max(1e3),
   nextCursor: Id3.nullable(),
   contentHash: Hash2
 }).strict().superRefine((page, context) => {
@@ -984,7 +1047,7 @@ var DatasetPopulationPageSchema = z4.object({
 var OpenPondDatasetPopulationClient = class {
   constructor(options) {
     this.options = options;
-    const url = new URL(options.baseUrl);
+    const url = new URL(options.baseUrl ?? DEFAULT_API_BASE_URL);
     if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim()) throw new Error("A clean API origin and workspace credentials are required.");
     this.baseUrl = url.toString().replace(/\/+$/, "");
   }
@@ -1013,7 +1076,7 @@ var OpenPondDatasetPopulationClient = class {
       reader.releaseLock();
     }
     const raw = JSON.parse(source);
-    if (!response.ok) throw new Error(z4.object({ message: z4.string() }).passthrough().parse(raw).message);
+    if (!response.ok) throw new Error(z5.object({ message: z5.string() }).passthrough().parse(raw).message);
     const page = DatasetPopulationPageSchema.parse(raw);
     const { contentHash: hash, ...content } = page;
     if (page.teamId !== this.options.teamId || contentHash(page.release) !== contentHash(query.release) || page.view !== query.view || page.items.length > query.limit || contentHash(content) !== hash || page.items.some((item, index) => query.afterId !== void 0 && item.id <= query.afterId || index > 0 && item.id <= page.items[index - 1].id) || page.nextCursor !== null && page.nextCursor !== page.items.at(-1)?.id) throw new Error("Dataset population identity, hash, order or bounds mismatch.");
@@ -1022,23 +1085,23 @@ var OpenPondDatasetPopulationClient = class {
 };
 
 // src/dataset-preparation-research-contracts.ts
-import { z as z5 } from "zod";
-var Id4 = z5.string().trim().min(1).max(240);
-var Text = z5.string().trim().min(1).max(5e3);
-var DatasetPreparationResearchCandidateSchema = z5.object({
+import { z as z6 } from "zod";
+var Id4 = z6.string().trim().min(1).max(240);
+var Text = z6.string().trim().min(1).max(5e3);
+var DatasetPreparationResearchCandidateSchema = z6.object({
   taskClass: DatasetPreparationTaskClassSchema,
-  objective: z5.string().trim().min(1).max(2e4),
-  sourceSpans: z5.array(PreparedTaskEvidenceSpanSchema).min(1).max(200),
-  firstAvailableAt: z5.iso.datetime(),
-  reconstruction: z5.object({
-    kind: z5.enum(["text_only", "pinned_repository", "pinned_artifact", "unsupported"]),
-    requiredAssets: z5.array(z5.object({ reference: Text, evidence: PreparedTaskEvidenceSpanSchema }).strict()).max(100),
-    missingEvidence: z5.array(Text).max(20)
+  objective: z6.string().trim().min(1).max(2e4),
+  sourceSpans: z6.array(PreparedTaskEvidenceSpanSchema).min(1).max(200),
+  firstAvailableAt: z6.iso.datetime(),
+  reconstruction: z6.object({
+    kind: z6.enum(["text_only", "pinned_repository", "pinned_artifact", "unsupported"]),
+    requiredAssets: z6.array(z6.object({ reference: Text, evidence: PreparedTaskEvidenceSpanSchema }).strict()).max(100),
+    missingEvidence: z6.array(Text).max(20)
   }).strict(),
-  assessment: z5.object({
-    kind: z5.enum(["executable", "calibrated_judge", "unsupported"]),
-    requirements: z5.array(z5.object({ criterion: Text, evidence: PreparedTaskEvidenceSpanSchema }).strict()).min(1).max(20),
-    limitations: z5.array(Text).max(20)
+  assessment: z6.object({
+    kind: z6.enum(["executable", "calibrated_judge", "unsupported"]),
+    requirements: z6.array(z6.object({ criterion: Text, evidence: PreparedTaskEvidenceSpanSchema }).strict()).min(1).max(20),
+    limitations: z6.array(Text).max(20)
   }).strict()
 }).strict().superRefine((value, ctx) => {
   if (!value.sourceSpans.some((span) => span.role === "requirement"))
@@ -1046,18 +1109,18 @@ var DatasetPreparationResearchCandidateSchema = z5.object({
   if (value.assessment.requirements.some((item) => item.evidence.role !== "requirement"))
     ctx.addIssue({ code: "custom", message: "Assessment criteria must cite user requirements, not historical answers." });
 });
-var DatasetPreparationResearchDecisionSchema = z5.object({
-  schemaVersion: z5.literal("openpond.datasetPreparationResearchDecision.v1"),
+var DatasetPreparationResearchDecisionSchema = z6.object({
+  schemaVersion: z6.literal("openpond.datasetPreparationResearchDecision.v1"),
   sourceId: Id4,
-  snapshotHash: z5.string().regex(/^[a-f0-9]{64}$/),
-  candidates: z5.array(DatasetPreparationResearchCandidateSchema).max(100),
-  exclusions: z5.array(z5.object({ code: Id4, reason: Text, sourceSpans: z5.array(PreparedTaskEvidenceSpanSchema).max(200) }).strict()).max(100),
-  contextSummary: z5.string().max(2e4)
+  snapshotHash: z6.string().regex(/^[a-f0-9]{64}$/),
+  candidates: z6.array(DatasetPreparationResearchCandidateSchema).max(100),
+  exclusions: z6.array(z6.object({ code: Id4, reason: Text, sourceSpans: z6.array(PreparedTaskEvidenceSpanSchema).max(200) }).strict()).max(100),
+  contextSummary: z6.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}$/);
+import { z as z7 } from "zod";
+var Hash3 = z7.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);
@@ -1070,11 +1133,11 @@ function parseConnectedStartingAssetReference(reference) {
   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}$/),
+var PreparedRepositoryStartingStateSchema = z7.object({
+  schemaVersion: z7.literal("openpond.preparedRepositoryStartingState.v1"),
+  dependencyClosureQualified: z7.literal(false),
+  assets: z7.array(ConnectedStartingAssetSchema.extend({
+    receiptId: z7.string().regex(/^starting-assets-[a-f0-9]{40}$/),
     receiptHash: Hash3,
     source: ConnectedCaseRefSchema
   }).strict()).min(1).max(100)
@@ -1278,55 +1341,55 @@ function reconcilePreparationSourceCoverage(input) {
 }
 
 // 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({
+import { z as z8 } from "zod";
+var Id5 = z8.string().trim().min(1).max(240);
+var Text2 = z8.string().trim().min(1).max(2e4);
+var PreparedQualificationWitnessSchema = z8.object({
   id: Id5,
-  label: z7.enum(["positive", "incorrect", "incomplete", "adversarial"]),
-  output: z7.record(z7.string(), z7.unknown()),
-  artifacts: z7.array(z7.object({
+  label: z8.enum(["positive", "incorrect", "incomplete", "adversarial"]),
+  output: z8.record(z8.string(), z8.unknown()),
+  artifacts: z8.array(z8.object({
     path: TaskRequiredOutputSchema.shape.path,
     mediaType: TaskRequiredOutputSchema.shape.mediaType,
-    base64: z7.string().max(8 * 1024 * 1024)
+    base64: z8.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)
+var PreparedQualificationPlanSchema = z8.object({
+  schemaVersion: z8.literal("openpond.preparedQualificationPlan.v1"),
+  requirementRefs: z8.array(Id5).min(1).max(100),
+  supported: z8.boolean(),
+  limitations: z8.array(Text2).max(20),
+  independentVerifier: z8.object({
+    runtime: z8.enum(["isolated_javascript", "sandbox_process"]),
+    source: z8.string().trim().min(1).max(2e5),
+    exportName: z8.literal("verify"),
+    timeoutMs: z8.number().int().min(1).max(6e4)
   }).strict().nullable(),
-  witnesses: z7.array(PreparedQualificationWitnessSchema).max(20)
+  witnesses: z8.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({
+var PreparedWitnessAdjudicationSchema = z8.object({
+  schemaVersion: z8.literal("openpond.preparedWitnessAdjudication.v1"),
+  witnesses: z8.array(z8.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)
+    failureMode: z8.enum(["none", "incorrect", "incomplete", "adversarial", "unverifiable"]),
+    requirements: z8.array(z8.object({ reference: Id5, status: z8.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()
+var PreparedCheckerAuditSchema = z8.object({
+  schemaVersion: z8.literal("openpond.preparedCheckerAudit.v1"),
+  requirements: z8.array(z8.object({ reference: Id5, adequatelyChecked: z8.boolean(), oracleAdequatelyChecked: z8.boolean(), reason: Text2 }).strict()).min(1).max(100),
+  executionIsolationPassed: z8.boolean(),
+  futureEvidenceLeak: z8.boolean(),
+  unresolvedLimitations: z8.array(Text2).max(20),
+  passed: z8.boolean()
 }).strict();
 
 // src/dataset-preparation-assembly.ts
@@ -1454,6 +1517,7 @@ export {
   DatasetWorkspaceOperationResultSchema,
   DatasetWorkspacePublishSchema,
   DatasetWorkspaceReceiptSchema,
+  DatasetWorkspaceRequestError,
   DatasetWorkspaceValidationSchema,
   DatasetWorkspaceVersionsSchema,
   DatasetWorkspaceWriteSchema,