openpond-sdk 0.11.5 → 0.12.0

package/dist/types/packages/sdk/src/dataset-preparation-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-preparation-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-preparation-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,mCAAmC;;;;;kBAOrC,CAAC;AAEZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;kBAkB/B,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;EAM5C,CAAC;AACH,eAAO,MAAM,6BAA6B;;;;;;;EAOxC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAezC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;kBAoBvC,CAAC;AAEL,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgEvC,CAAC;AAEL,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMhC,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;8BAkB1C,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;kBAmBlC,CAAC;AAEZ,eAAO,MAAM,kCAAkC;;;;;;;;kBAUpC,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DjC,CAAC;AAEZ,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkGpC,CAAC;AAEL,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO9B,CAAC;AAEZ;6DAC6D;AAC7D,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;kBAoBvC,CAAC;AAEL,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuCrC,CAAC;AAEL,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+FxC,CAAC;AAEL,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqD1C,CAAC;AAEL,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC"}

package/dist/types/packages/sdk/src/dataset-preparation-qualification-contracts.d.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+export declare const PreparedQualificationWitnessSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodEnum<{
+        positive: "positive";
+        adversarial: "adversarial";
+        incorrect: "incorrect";
+        incomplete: "incomplete";
+    }>;
+    output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        mediaType: z.ZodString;
+        base64: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Generated from original requirements before seeing the authored checker or
+ * proposed answers. The plan remains privileged, unqualified evidence. */
+export declare const PreparedQualificationPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preparedQualificationPlan.v1">;
+    requirementRefs: z.ZodArray<z.ZodString>;
+    supported: z.ZodBoolean;
+    limitations: z.ZodArray<z.ZodString>;
+    independentVerifier: z.ZodNullable<z.ZodObject<{
+        runtime: z.ZodEnum<{
+            isolated_javascript: "isolated_javascript";
+            sandbox_process: "sandbox_process";
+        }>;
+        source: z.ZodString;
+        exportName: z.ZodLiteral<"verify">;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    witnesses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodEnum<{
+            positive: "positive";
+            adversarial: "adversarial";
+            incorrect: "incorrect";
+            incomplete: "incomplete";
+        }>;
+        output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        artifacts: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            base64: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PreparedQualificationPlan = z.infer<typeof PreparedQualificationPlanSchema>;
+export type PreparedQualificationWitness = z.infer<typeof PreparedQualificationWitnessSchema>;
+/** A second, blinded adjudication sees source requirements and actual witness
+ * outputs, but no planned labels, verifier code or claimed checker verdicts. */
+export declare const PreparedWitnessAdjudicationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preparedWitnessAdjudication.v1">;
+    witnesses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        failureMode: z.ZodEnum<{
+            none: "none";
+            adversarial: "adversarial";
+            incorrect: "incorrect";
+            incomplete: "incomplete";
+            unverifiable: "unverifiable";
+        }>;
+        requirements: z.ZodArray<z.ZodObject<{
+            reference: z.ZodString;
+            status: z.ZodEnum<{
+                unverifiable: "unverifiable";
+                satisfied: "satisfied";
+                violated: "violated";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PreparedWitnessAdjudication = z.infer<typeof PreparedWitnessAdjudicationSchema>;
+export declare const PreparedCheckerAuditSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preparedCheckerAudit.v1">;
+    requirements: z.ZodArray<z.ZodObject<{
+        reference: z.ZodString;
+        adequatelyChecked: z.ZodBoolean;
+        oracleAdequatelyChecked: z.ZodBoolean;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    executionIsolationPassed: z.ZodBoolean;
+    futureEvidenceLeak: z.ZodBoolean;
+    unresolvedLimitations: z.ZodArray<z.ZodString>;
+    passed: z.ZodBoolean;
+}, z.core.$strict>;
+//# sourceMappingURL=dataset-preparation-qualification-contracts.d.ts.map

package/dist/types/packages/sdk/src/dataset-preparation-qualification-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-preparation-qualification-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-preparation-qualification-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;kBAU7C,CAAC;AAEH;0EAC0E;AAC1E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgB1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F;gFACgF;AAChF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;kBAOnC,CAAC;AACZ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;kBAM5B,CAAC"}

package/dist/types/packages/sdk/src/dataset-preparation-research-contracts.d.ts

@@ -0,0 +1,203 @@
+import { z } from "zod";
+export declare const DatasetPreparationResearchCandidateSchema: z.ZodObject<{
+    taskClass: z.ZodEnum<{
+        coding_change: "coding_change";
+        debugging: "debugging";
+        code_explanation: "code_explanation";
+        structured_text: "structured_text";
+        artifact_work: "artifact_work";
+    }>;
+    objective: z.ZodString;
+    sourceSpans: z.ZodArray<z.ZodObject<{
+        source: z.ZodObject<{
+            id: z.ZodString;
+            snapshotHash: z.ZodString;
+            boundaryId: z.ZodString;
+            boundaryRevisionHash: z.ZodString;
+        }, z.core.$strict>;
+        startSequence: z.ZodNumber;
+        endSequence: z.ZodNumber;
+        role: z.ZodEnum<{
+            outcome: "outcome";
+            correction: "correction";
+            requirement: "requirement";
+            initial_context: "initial_context";
+            verification: "verification";
+        }>;
+    }, z.core.$strict>>;
+    firstAvailableAt: z.ZodISODateTime;
+    reconstruction: z.ZodObject<{
+        kind: z.ZodEnum<{
+            unsupported: "unsupported";
+            text_only: "text_only";
+            pinned_repository: "pinned_repository";
+            pinned_artifact: "pinned_artifact";
+        }>;
+        requiredAssets: z.ZodArray<z.ZodObject<{
+            reference: z.ZodString;
+            evidence: z.ZodObject<{
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    snapshotHash: z.ZodString;
+                    boundaryId: z.ZodString;
+                    boundaryRevisionHash: z.ZodString;
+                }, z.core.$strict>;
+                startSequence: z.ZodNumber;
+                endSequence: z.ZodNumber;
+                role: z.ZodEnum<{
+                    outcome: "outcome";
+                    correction: "correction";
+                    requirement: "requirement";
+                    initial_context: "initial_context";
+                    verification: "verification";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        missingEvidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    assessment: z.ZodObject<{
+        kind: z.ZodEnum<{
+            executable: "executable";
+            calibrated_judge: "calibrated_judge";
+            unsupported: "unsupported";
+        }>;
+        requirements: z.ZodArray<z.ZodObject<{
+            criterion: z.ZodString;
+            evidence: z.ZodObject<{
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    snapshotHash: z.ZodString;
+                    boundaryId: z.ZodString;
+                    boundaryRevisionHash: z.ZodString;
+                }, z.core.$strict>;
+                startSequence: z.ZodNumber;
+                endSequence: z.ZodNumber;
+                role: z.ZodEnum<{
+                    outcome: "outcome";
+                    correction: "correction";
+                    requirement: "requirement";
+                    initial_context: "initial_context";
+                    verification: "verification";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Each chunk replaces the coherent accumulated decision for that exact
+ * conversation revision. It is a proposal, never qualification evidence. */
+export declare const DatasetPreparationResearchDecisionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.datasetPreparationResearchDecision.v1">;
+    sourceId: z.ZodString;
+    snapshotHash: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        taskClass: z.ZodEnum<{
+            coding_change: "coding_change";
+            debugging: "debugging";
+            code_explanation: "code_explanation";
+            structured_text: "structured_text";
+            artifact_work: "artifact_work";
+        }>;
+        objective: z.ZodString;
+        sourceSpans: z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                id: z.ZodString;
+                snapshotHash: z.ZodString;
+                boundaryId: z.ZodString;
+                boundaryRevisionHash: z.ZodString;
+            }, z.core.$strict>;
+            startSequence: z.ZodNumber;
+            endSequence: z.ZodNumber;
+            role: z.ZodEnum<{
+                outcome: "outcome";
+                correction: "correction";
+                requirement: "requirement";
+                initial_context: "initial_context";
+                verification: "verification";
+            }>;
+        }, z.core.$strict>>;
+        firstAvailableAt: z.ZodISODateTime;
+        reconstruction: z.ZodObject<{
+            kind: z.ZodEnum<{
+                unsupported: "unsupported";
+                text_only: "text_only";
+                pinned_repository: "pinned_repository";
+                pinned_artifact: "pinned_artifact";
+            }>;
+            requiredAssets: z.ZodArray<z.ZodObject<{
+                reference: z.ZodString;
+                evidence: z.ZodObject<{
+                    source: z.ZodObject<{
+                        id: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryId: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>;
+                    startSequence: z.ZodNumber;
+                    endSequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        outcome: "outcome";
+                        correction: "correction";
+                        requirement: "requirement";
+                        initial_context: "initial_context";
+                        verification: "verification";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            missingEvidence: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        assessment: z.ZodObject<{
+            kind: z.ZodEnum<{
+                executable: "executable";
+                calibrated_judge: "calibrated_judge";
+                unsupported: "unsupported";
+            }>;
+            requirements: z.ZodArray<z.ZodObject<{
+                criterion: z.ZodString;
+                evidence: z.ZodObject<{
+                    source: z.ZodObject<{
+                        id: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryId: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>;
+                    startSequence: z.ZodNumber;
+                    endSequence: z.ZodNumber;
+                    role: z.ZodEnum<{
+                        outcome: "outcome";
+                        correction: "correction";
+                        requirement: "requirement";
+                        initial_context: "initial_context";
+                        verification: "verification";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            limitations: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    exclusions: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        reason: z.ZodString;
+        sourceSpans: z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                id: z.ZodString;
+                snapshotHash: z.ZodString;
+                boundaryId: z.ZodString;
+                boundaryRevisionHash: z.ZodString;
+            }, z.core.$strict>;
+            startSequence: z.ZodNumber;
+            endSequence: z.ZodNumber;
+            role: z.ZodEnum<{
+                outcome: "outcome";
+                correction: "correction";
+                requirement: "requirement";
+                initial_context: "initial_context";
+                verification: "verification";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    contextSummary: z.ZodString;
+}, z.core.$strict>;
+export type DatasetPreparationResearchCandidate = z.infer<typeof DatasetPreparationResearchCandidateSchema>;
+export type DatasetPreparationResearchDecision = z.infer<typeof DatasetPreparationResearchDecisionSchema>;
+//# sourceMappingURL=dataset-preparation-research-contracts.d.ts.map

package/dist/types/packages/sdk/src/dataset-preparation-research-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-preparation-research-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-preparation-research-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBpD,CAAC;AAEH;4EAC4E;AAC5E,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO1C,CAAC;AACZ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAC5G,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wCAAwC,CAAC,CAAC"}

package/dist/types/packages/sdk/src/dataset-preparation-starting-state.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare function connectedStartingAssetReference(receiptId: string, path: string): string;
+export declare function parseConnectedStartingAssetReference(reference: string): {
+    receiptId: string;
+    path: string;
+};
+/** A host-owned selection of immutable bytes. Dependency sufficiency and
+ * executable outcome checks still require isolated qualification. */
+export declare const PreparedRepositoryStartingStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preparedRepositoryStartingState.v1">;
+    dependencyClosureQualified: z.ZodLiteral<false>;
+    assets: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        commitHash: z.ZodString;
+        gitObjectHash: z.ZodString;
+        mode: z.ZodEnum<{
+            100644: "100644";
+            100755: "100755";
+        }>;
+        sizeBytes: z.ZodNumber;
+        sha256: z.ZodString;
+        receiptId: z.ZodString;
+        receiptHash: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            snapshotHash: z.ZodString;
+            boundaryId: z.ZodString;
+            boundaryRevisionHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PreparedRepositoryStartingState = z.infer<typeof PreparedRepositoryStartingStateSchema>;
+export declare function preparedRepositoryEnvironment(): {
+    protocolVersion: "openpond.taskEnvironment.v1";
+    kind: "agent" | "work" | "chat" | "program" | "stateful_harness";
+    entrypoint: string;
+    stateful: boolean;
+    deterministicSeeds: boolean;
+    toolNames: string[];
+    lifecycle: ("grade" | "create" | "reset" | "step" | "cleanup")[];
+    defaultTimeoutMs: number;
+    networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+    metadata: Record<string, unknown>;
+    actionBindings?: {
+        schemaVersion: "openpond.harnessActionBinding.v1";
+        actionId: string;
+        modelToolName: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        actionSchemaHash: string;
+        agentRelease: {
+            id: string;
+            contentHash: string;
+        };
+        implementationHash: string;
+        runtimeBindingId: string;
+        capabilityReceiptHash: string;
+        sideEffect: "read" | "write";
+        studentVisible: boolean;
+        timeoutMs: number;
+        episodeArgumentBindings: {
+            argument: string;
+            source: "case_id";
+        }[];
+    }[] | undefined;
+    resources?: {
+        id: string;
+        kind: "file" | "configuration" | "catalog" | "code_module";
+        path: string;
+        visibility: "privileged" | "policy_visible" | "policy_hidden";
+        required: boolean;
+        metadata: Record<string, unknown>;
+        mediaType?: string | null | undefined;
+    }[] | undefined;
+};
+//# sourceMappingURL=dataset-preparation-starting-state.d.ts.map

package/dist/types/packages/sdk/src/dataset-preparation-starting-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-preparation-starting-state.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-preparation-starting-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAI9E;AACD,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,MAAM;;;EAMrE;AAED;qEACqE;AACrE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;kBAahD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG,wBAAgB,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5C"}