openpond-sdk 0.3.3 → 0.4.0

package/dist/types/packages/sdk/src/taskset-authored-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskset-authored-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-authored-contracts.ts"],"names":[],"mappings":"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"}

package/dist/types/packages/sdk/src/taskset-authored-files.d.ts

@@ -0,0 +1,560 @@
+import { z } from "zod";
+import { type GeneratedTaskFile, type Taskset } from "./taskset-authored-contracts.js";
+export declare const AuthoredTasksetFileInventorySchema: z.ZodArray<z.ZodObject<{
+    asset: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    sourcePath: z.ZodString;
+}, z.core.$strict>>;
+export declare function isGeneratedTasksetPublicationFilePath(path: string): boolean;
+/** Seal one captured file population; hosts own filesystem or object-store capture. */
+export declare function prepareAuthoredTasksetSource(tasksetInput: Taskset, sourceFiles: ReadonlyMap<string, Uint8Array>, adapterId: string): {
+    taskset: {
+        schemaVersion: "openpond.taskset.v1";
+        id: string;
+        revision: number;
+        profileId: string;
+        createImproveRunId: string | null;
+        name: string;
+        objective: string;
+        purpose: "benchmark" | "general";
+        benchmark: {
+            schemaVersion: "openpond.tasksetBenchmark.v1";
+            definitionId: string;
+            releaseId: string;
+            releaseHash: string;
+            managedReleasePath: string;
+            adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+            evaluationSplit: "train" | "validation" | "test" | "frozen_eval";
+            primaryMetric: "foreground_tokens" | "success_rate" | "latency_ms" | "cost_usd";
+            qualityGate: "none" | "non_regression" | "all_pass";
+            source: "builtin" | "imported";
+            metadata: Record<string, unknown>;
+        } | null;
+        preferenceComparison: {
+            schemaVersion: "openpond.tasksetPreferenceComparisonBinding.v1";
+            releaseId: string;
+            releaseHash: string;
+            publishedAt: string;
+            metadata: Record<string, unknown>;
+        } | null;
+        status: "failed" | "archived" | "ready" | "draft" | "awaiting_disclosure_approval" | "awaiting_materialization_approval" | "materializing" | "validating" | "needs_review" | "baselining" | "blocked";
+        sourceRefs: ({
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.huggingFaceDatasetSource.v1";
+            kind: "huggingface";
+            repositoryId: string;
+            repositoryUrl: string;
+            revision: string;
+            configuration: string;
+            upstreamSplits: string[];
+            gated: boolean;
+            private: boolean;
+            declaredLicense: string | null;
+            sourceFileHashes: string[];
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.uploadedFileDatasetSource.v1";
+            kind: "uploaded_file";
+            originalFileNames: string[];
+            mediaTypes: string[];
+            sourceFileHashes: string[];
+            totalBytes: number;
+            parserVersion: string;
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.generatedDatasetSource.v1";
+            kind: "generated";
+            generatorId: string;
+            generatorVersion: string;
+            seed: number;
+            generatorHash: string;
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.learningBatchDatasetSource.v1";
+            kind: "learning_batch";
+            batch: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            taskDefinition: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            admittedBy: string;
+        } | {
+            schemaVersion: "openpond.trainingSource.v1";
+            id: string;
+            profileId: string;
+            sessionId: string;
+            turnIds: string[];
+            workspaceId: string | null;
+            sourceHash: string;
+            clusterKey: string;
+            title: string;
+            occurredAt: string;
+            consent: {
+                status: "pending" | "granted" | "denied" | "revoked";
+                scope: "metadata_only" | "selected_turns" | "full_session";
+                grantedBy: string | null;
+                grantedAt: string | null;
+                purpose: "task_authoring_and_evaluation";
+            };
+            connectedAppIds: string[];
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            metadata: Record<string, unknown>;
+        })[];
+        policy: {
+            policyVisibleFields: string[];
+            privilegedFields: string[];
+            hiddenGraderRefs: string[];
+            connectedAppScopes: string[];
+        };
+        environment: {
+            protocolVersion: "openpond.taskEnvironment.v1";
+            kind: "work" | "agent" | "chat" | "program" | "stateful_harness";
+            entrypoint: string;
+            stateful: boolean;
+            deterministicSeeds: boolean;
+            toolNames: string[];
+            lifecycle: ("cleanup" | "create" | "grade" | "reset" | "step")[];
+            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" | "catalog" | "configuration" | "code_module";
+                path: string;
+                visibility: "privileged" | "policy_visible" | "policy_hidden";
+                required: boolean;
+                metadata: Record<string, unknown>;
+                mediaType?: string | null | undefined;
+            }[] | undefined;
+        };
+        capabilities: {
+            schemaVersion: "openpond.tasksetCapabilities.v1";
+            taskKind: "custom_program" | "chat" | "single_agent" | "multi_agent";
+            supportedSignals: ("label" | "reward" | "feedback" | "preference" | "demonstration" | "correction")[];
+            compatibleMethods: ("none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval")[];
+            rewardKinds: ("none" | "model_judge" | "human" | "deterministic" | "exact")[];
+            requiresTools: boolean;
+            requiresState: boolean;
+            requiresPrivilegedGrading: boolean;
+            environmentPlacements: ("local" | "remote" | "colocated" | "provider_native")[];
+            exportable: boolean;
+            portabilityBlockers: string[];
+        };
+        tasks: {
+            schemaVersion: "openpond.taskData.v1";
+            id: string;
+            clusterKey: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, unknown>;
+            expectedOutput: Record<string, unknown> | null;
+            policyVisibleContext: Record<string, unknown>;
+            privilegedContextRef: string | null;
+            sourceRefs: string[];
+            tags: string[];
+            metadata: Record<string, unknown>;
+            assets?: {
+                id: string;
+                sourceRefId: string;
+                artifactRef: string;
+                fileName: string;
+                mediaType: string;
+                sha256: string;
+                sizeBytes: number;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+            resourceRefs?: string[] | undefined;
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                metadata: Record<string, unknown>;
+                schemaRef?: string | null | undefined;
+                maxBytes?: number | undefined;
+            }[] | undefined;
+        }[];
+        graders: ({
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "file" | "state" | "test" | "content" | "schema" | "runtime_event" | "diff";
+            config: Record<string, unknown>;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "model_judge";
+            rubric: string;
+            judge: {
+                providerId: "openpond" | "codex" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq" | "custom-openai-compatible";
+                modelId: string;
+            };
+            calibrationFixtureRefs: string[];
+            calibrationStatus: "failed" | "pending" | "passed";
+            temperature: number;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "human";
+            rubric: string;
+            reviewerRole: string;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "custom_verifier";
+            module: string;
+            exportName: string;
+            timeoutMs: number;
+            networkPolicy: "none";
+        })[];
+        graderFixtures: {
+            id: string;
+            taskId: string;
+            label: "infrastructure_failure" | "positive" | "negative" | "boundary" | "adversarial" | "prompt_injection";
+            output: Record<string, unknown>;
+            infrastructureError: string | null;
+            expectedPassed: boolean;
+            expectedRewardEligible: boolean;
+            metadata: Record<string, unknown>;
+        }[];
+        learningSignals: {
+            demonstrations: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "demonstration";
+                prompt: string | null;
+                response: string | null;
+            }[];
+            preferences: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "preference";
+                prompt: string;
+                chosen: string;
+                rejected: string;
+                rationale: string | null;
+            }[];
+            corrections: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "correction";
+                original: string;
+                corrected: string;
+                rationale: string | null;
+            }[];
+            feedback: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "feedback";
+                feedback: string;
+                polarity: "neutral" | "positive" | "negative" | "mixed";
+            }[];
+            rewards: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "reward";
+                task: string;
+                rules: {
+                    id: string;
+                    points: number;
+                    condition: string;
+                }[];
+                otherwisePoints: number;
+                executable: boolean;
+            }[];
+            labels: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "label";
+                labelKind: "rubric";
+                task: string;
+                criteria: {
+                    id: string;
+                    label: string;
+                    description: string;
+                }[];
+                calibrationExamples: {
+                    positive: string;
+                    negative: string;
+                    boundary: string;
+                };
+            }[];
+        };
+        authoringProvenance: {
+            schemaVersion: "openpond.taskAuthoringProvenance.v1";
+            model: {
+                providerId: "openpond" | "codex" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq" | "custom-openai-compatible";
+                modelId: string;
+            } | null;
+            modelConfig: Record<string, unknown>;
+            skillHash: string;
+            promptTemplateVersion: string;
+            buildIntent: "rubric" | "demonstrations" | "preferences" | "verifiable_reward" | "discovery";
+            buildSpecification: {
+                kind: "demonstrations";
+                behavior: string;
+                examples: {
+                    id: string;
+                    prompt: string;
+                    response: string;
+                }[];
+            } | {
+                kind: "preferences";
+                preference: string;
+                pairs: {
+                    id: string;
+                    prompt: string;
+                    chosen: string;
+                    rejected: string;
+                    rationale: string;
+                }[];
+            } | {
+                kind: "verifiable_reward";
+                task: string;
+                rules: {
+                    id: string;
+                    points: number;
+                    condition: string;
+                }[];
+                otherwisePoints: number;
+            } | {
+                kind: "rubric";
+                task: string;
+                criteria: {
+                    id: string;
+                    label: string;
+                    description: string;
+                }[];
+                positiveExample: string;
+                negativeExample: string;
+                boundaryExample: string;
+            } | null;
+            evidenceHashes: string[];
+            tasksetSdkVersion: string;
+            sourceCommit: string | null;
+            repairHistory: {
+                attempt: number;
+                summary: string;
+                createdAt: string;
+            }[];
+            createdAt: string;
+        };
+        readiness: {
+            schemaVersion: "openpond.tasksetReadiness.v1";
+            tasksetId: string;
+            tasksetHash: string;
+            ready: boolean;
+            recommendedMethod: "none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval";
+            trainingPath: {
+                primaryMethod: "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opsd" | "sdpo";
+                bootstrap: {
+                    method: "sft";
+                    purpose: "trajectory_bootstrap";
+                    demonstrationRefs: string[];
+                    limitations: string[];
+                } | null;
+            } | null;
+            methodReadiness: {
+                method: "sft" | "dpo" | "grpo" | "ppo";
+                status: "recommended" | "compatible" | "needs_dataset_work";
+                reasonCodes: ("taskset_not_ready" | "demonstrations_missing" | "preference_pairs_missing" | "preference_pairs_invalid" | "executable_reward_missing" | "reward_not_calibrated" | "reward_model_missing" | "value_model_required" | "frozen_eval_missing")[];
+                reasons: string[];
+            }[];
+            compatibleDestinationClasses: ("custom" | "export" | "hosted_managed")[];
+            blockers: {
+                code: string;
+                message: string;
+                path: string | null;
+            }[];
+            advisories: {
+                code: string;
+                message: string;
+                path: string | null;
+            }[];
+            warnings: string[];
+            generatedAt: string;
+        } | null;
+        contentHash: string;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, unknown>;
+        profileRelease?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null | undefined;
+        datasetArtifact?: {
+            schemaVersion: "openpond.datasetArtifact.v1";
+            id: string;
+            tasksetId: string;
+            tasksetRevision: number;
+            contentHash: string;
+            format: "parquet";
+            schema: {
+                schemaVersion: "openpond.datasetSemanticSchema.v1";
+                fields: {
+                    name: string;
+                    semanticRole: "metadata" | "prompt" | "reward" | "feedback" | "rejected" | "messages" | "row_id" | "cluster_id" | "demonstration" | "chosen" | "expected_output" | "privileged_context" | "tag";
+                    logicalType: "string" | "boolean" | "messages" | "integer" | "float" | "json";
+                    nullable: boolean;
+                    policy: "metadata" | "privileged" | "visible";
+                }[];
+                schemaHash: string;
+            };
+            shards: {
+                id: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                path: string;
+                contentHash: string;
+                schemaHash: string;
+                sizeBytes: number;
+                rowCount: number;
+                rowGroupCount: number;
+            }[];
+            rowCount: number;
+            splitCounts: Record<"train" | "validation" | "test" | "frozen_eval", number>;
+            sourceReceiptRefs: string[];
+            mappingHash: string;
+            qualityReportHash: string;
+            createdAt: string;
+        } | null | undefined;
+        metrics?: {
+            schemaVersion: "openpond.tasksetMetricPolicy.v1";
+            primaryMetric: string;
+            aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
+            missingReward: "zero" | "exclude";
+            customAggregator: {
+                module: string;
+                exportName: string;
+                contentHash: string;
+                timeoutMs: number;
+                networkPolicy: "none";
+            } | null;
+            taskWeights?: Record<string, number> | undefined;
+        } | undefined;
+    };
+    generatedFiles: GeneratedTaskFile[];
+};
+//# sourceMappingURL=taskset-authored-files.d.ts.map

package/dist/types/packages/sdk/src/taskset-authored-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskset-authored-files.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-authored-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAiB,KAAK,iBAAiB,EAAE,KAAK,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAOtG,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;mBAEvB,CAAC;AAGzB,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAA0C;AAEtH,uFAAuF;AACvF,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEU,iBAAiB,EAAE;EA+E/J"}

package/dist/types/packages/sdk/src/taskset-authored-portable-release.d.ts

@@ -0,0 +1,92 @@
+import type { Taskset } from "./taskset-authored-contracts.js";
+import type { TaskDataRecord } from "./taskset-draft-core.js";
+import { createEnvironmentRelease, createVerifierSetRelease, type EnvironmentContract, type PreferenceComparisonRelease, type TasksetRelease } from "@openpond/evals";
+import type { ToolDeclaration } from "@openpond/harness";
+import { type RewardBinding, type RewardRelease } from "@openpond/evals/rewards";
+export type TasksetRewardExecution = {
+    binding: RewardBinding;
+    rewards: RewardRelease[];
+};
+export declare function resolvePortableTasksetRewardExecution(taskset: Taskset, supplied?: TasksetRewardExecution): TasksetRewardExecution | null;
+export declare function materializePortableTasksetRelease(input: {
+    taskset: Taskset;
+    selectedTasks?: TaskDataRecord[];
+    adapterId: string;
+    admittedTasksetRelease?: TasksetRelease | null;
+    rewardExecution?: TasksetRewardExecution;
+}): {
+    environmentRelease: ReturnType<typeof createEnvironmentRelease>;
+    verifierSetRelease: ReturnType<typeof createVerifierSetRelease>;
+    tasksetRelease: TasksetRelease;
+};
+/**
+ * Admits a published comparison policy against the exact portable Taskset
+ * release it names. A comparison is deliberately not embedded in that release:
+ * doing so would create a content-hash cycle between Taskset and comparison.
+ */
+export declare function projectPreferenceComparisonRelease(input: {
+    tasksetRelease: TasksetRelease;
+    preferenceComparison: PreferenceComparisonRelease;
+}): PreferenceComparisonRelease;
+export declare function portableTasksetEnvironment(taskset: Taskset): EnvironmentContract;
+export declare function portableTasksetTools(taskset: Taskset): ToolDeclaration[];
+/** Preserve immutable file/schema references while overlaying current edits. */
+export declare function projectPortableTaskRecord(task: TaskDataRecord): {
+    id: string;
+    clusterKey: string;
+    split: "train" | "validation" | "test" | "frozen_eval";
+    input: Record<string, unknown>;
+    expectedOutput: Record<string, unknown> | null;
+    policyVisibleContext: Record<string, unknown>;
+    privilegedContextRef: string | null;
+    artifactRefs: {
+        id: string;
+        path: string;
+        contentHash: string;
+        sizeBytes: number;
+        mediaType: string;
+        visibility: "policy" | "verifier" | "host_private";
+    }[];
+    tags: string[];
+    requiredOutputs?: {
+        path: string;
+        mediaType: string;
+        schemaRef: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        } | null;
+        maxBytes: number | null;
+        metadata: Record<string, unknown>;
+    }[] | undefined;
+} | {
+    id: string;
+    clusterKey: string;
+    split: "train" | "validation" | "test" | "frozen_eval";
+    input: Record<string, unknown>;
+    expectedOutput: Record<string, unknown> | null;
+    policyVisibleContext: Record<string, unknown>;
+    privilegedContextRef: string | null;
+    artifactRefs: {
+        id: string;
+        path: string;
+        contentHash: string;
+        sizeBytes: number;
+        mediaType: string;
+        visibility: "policy";
+    }[];
+    requiredOutputs: {
+        path: string;
+        mediaType: string;
+        schemaRef: null;
+        maxBytes: number | null;
+        metadata: {
+            legacySchemaRef: string | null;
+        };
+    }[];
+    tags: string[];
+};
+//# sourceMappingURL=taskset-authored-portable-release.d.ts.map

package/dist/types/packages/sdk/src/taskset-authored-portable-release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskset-authored-portable-release.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-authored-portable-release.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAML,wBAAwB,EACxB,wBAAwB,EAMxB,KAAK,mBAAmB,EAExB,KAAK,2BAA2B,EAChC,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAEV,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAS3B,OAAO,EAAiE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGhJ,MAAM,MAAM,sBAAsB,GAAG;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,aAAa,EAAE,CAAA;CAAE,CAAC;AAE1F,wBAAgB,qCAAqC,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,sBAAsB,GAAG,sBAAsB,GAAG,IAAI,CAgBxI;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE;IACvD,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,cAAc,EAAE,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,sBAAsB,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,sBAAsB,CAAC;CAC1C,GAAG;IACF,kBAAkB,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC;IAChE,kBAAkB,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC;IAChE,cAAc,EAAE,cAAc,CAAC;CAChC,CAiGA;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,KAAK,EAAE;IACxD,cAAc,EAAE,cAAc,CAAC;IAC/B,oBAAoB,EAAE,2BAA2B,CAAC;CACnD,GAAG,2BAA2B,CAY9B;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAEhF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,EAAE,CAExE;AAED,gFAAgF;AAChF,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwE7D"}

package/dist/types/packages/sdk/src/taskset-authored-tool-environment.d.ts

@@ -0,0 +1,15 @@
+import { type GeneratedTaskFile, type Taskset } from "./taskset-authored-contracts.js";
+import { type ImmutableAssetRef } from "@openpond/harness";
+type Inventory = Array<{
+    asset: ImmutableAssetRef;
+    sourcePath: string;
+}>;
+/** Source bytes change in the draft; publication owns all executable hashes.
+ * The private declaration is regenerated with the newly compiled verifiers. */
+export declare function prepareAuthoredToolEnvironment(taskset: Taskset, bytes: Map<string, Uint8Array>, inventory: Inventory, adapterId: string): {
+    taskset: Taskset;
+    inventory: Inventory;
+    generatedFiles: GeneratedTaskFile[];
+};
+export {};
+//# sourceMappingURL=taskset-authored-tool-environment.d.ts.map