openpond-sdk 0.11.5 → 0.12.0

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

@@ -0,0 +1,630 @@
+import { type TasksetDraftWorkspaceFile } from "./taskset-draft-workspace.js";
+import { type PreparedRepositoryStartingState } from "./dataset-preparation-starting-state.js";
+import type { PreparedTaskProvenance } from "./dataset-preparation-contracts.js";
+import type { TaskDesignProposal } from "./task-design-contracts.js";
+import type { TasksetSourceRef } from "./taskset-draft-core.js";
+/** This creates a private, unqualified draft. Publication and execution stay
+ * with their existing owners; no authorer can replace the reconstructed input. */
+export declare function createPreparedTaskAuthoringWorkspace(input: {
+    teamId: string;
+    provenance: PreparedTaskProvenance;
+    initialInput: Record<string, unknown>;
+    initialEnvironment: Record<string, unknown>;
+    startingFiles?: TasksetDraftWorkspaceFile[];
+    startingAssets?: PreparedRepositoryStartingState | null;
+    proposal: TaskDesignProposal;
+    sources: TasksetSourceRef[];
+    skillHash: string;
+    modelId: string;
+    attempt: number;
+    createdAt: string;
+}): {
+    schemaVersion: "openpond.tasksetDraftWorkspace.v1";
+    draft: {
+        schemaVersion: "openpond.tasksetDraft.v1";
+        id: string;
+        revision: number;
+        profileId: string;
+        modelScope: {
+            modelId: string;
+            expectedModelRevision: number;
+            source?: {
+                schemaVersion: "openpond.modelTasksetDraftPreparation.v1";
+                draftId: string;
+                requestHash: string;
+                sourcePackageHash: string;
+                sourceTasksetRef: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                tasksetId: string;
+                tasksetRevision: number;
+                lineage: {
+                    schemaVersion: "openpond.modelTasksetAuthoring.v1";
+                    owner: {
+                        scopeId: string;
+                        modelId: string;
+                    };
+                    root: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    parent: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                };
+                authoringGraph?: "bound" | undefined;
+            } | undefined;
+        } | null;
+        name: string;
+        objective: string;
+        purpose: "general" | "benchmark";
+        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: "draft" | "validating" | "needs_review" | "published";
+        sourceRefs: ({
+            schemaVersion: "openpond.connectedDatasetSource.v1";
+            kind: "connected_activity";
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "approved" | "review" | "blocked";
+            secretScanStatus: "passed" | "pending" | "blocked";
+            piiScanStatus: "passed" | "pending" | "review" | "blocked";
+            origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+            sourceId: string;
+            sessionId: string;
+            normalizerVersion: string;
+            projection: "turn" | "conversation";
+            ownerUserId: string;
+            purpose: "recorded_evaluation";
+            metadata: Record<string, unknown>;
+            sourceFileHashes?: string[] | undefined;
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "approved" | "review" | "blocked";
+            secretScanStatus: "passed" | "pending" | "blocked";
+            piiScanStatus: "passed" | "pending" | "review" | "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" | "approved" | "review" | "blocked";
+            secretScanStatus: "passed" | "pending" | "blocked";
+            piiScanStatus: "passed" | "pending" | "review" | "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" | "approved" | "review" | "blocked";
+            secretScanStatus: "passed" | "pending" | "blocked";
+            piiScanStatus: "passed" | "pending" | "review" | "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" | "approved" | "review" | "blocked";
+            secretScanStatus: "passed" | "pending" | "blocked";
+            piiScanStatus: "passed" | "pending" | "review" | "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: "passed" | "pending" | "blocked";
+            piiScanStatus: "passed" | "pending" | "review" | "blocked";
+            licensingStatus: "pending" | "approved" | "review" | "blocked";
+            metadata: Record<string, unknown>;
+        })[];
+        policy: {
+            policyVisibleFields: string[];
+            privilegedFields: string[];
+            hiddenGraderRefs: string[];
+            connectedAppScopes: string[];
+        };
+        environment: {
+            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;
+        };
+        output: {
+            mode: "text" | "structured_json" | "artifacts";
+            jsonSchema: Record<string, unknown> | null;
+            renderer: {
+                module: string;
+                exportName: string;
+                configRef: string | null;
+            } | null;
+        };
+        capabilities: {
+            schemaVersion: "openpond.tasksetCapabilities.v1";
+            taskKind: "chat" | "single_agent" | "multi_agent" | "custom_program";
+            supportedSignals: ("label" | "preference" | "feedback" | "demonstration" | "reward" | "correction")[];
+            compatibleMethods: ("none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval")[];
+            rewardKinds: ("none" | "exact" | "deterministic" | "model_judge" | "human")[];
+            requiresTools: boolean;
+            requiresState: boolean;
+            requiresPrivilegedGrading: boolean;
+            environmentPlacements: ("local" | "remote" | "colocated" | "provider_native")[];
+            exportable: boolean;
+            portabilityBlockers: string[];
+        };
+        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;
+        };
+        review: {
+            enabled: boolean;
+            candidateCount: number;
+            minimumSamples: number;
+            allowTies: boolean;
+            allowRejectAll: boolean;
+            rubric: string;
+            criteria: {
+                id: string;
+                label: string;
+                description: string;
+                weight: number;
+            }[];
+        };
+        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;
+            tags: string[];
+            metadata: Record<string, unknown>;
+            sourceRefs: string[];
+            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>;
+                stagingPath?: string | undefined;
+            }[] | 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" | "content" | "state" | "test" | "diff" | "schema" | "runtime_event";
+            config: Record<string, unknown>;
+            taskIds?: string[] | undefined;
+        } | {
+            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: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                modelId: string;
+            };
+            calibrationFixtureRefs: string[];
+            calibrationStatus: "passed" | "pending" | "failed";
+            temperature: number;
+            taskIds?: string[] | undefined;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "human";
+            rubric: string;
+            reviewerRole: string;
+            taskIds?: string[] | undefined;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "category";
+                    options: string[];
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "boolean";
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "text";
+                    maximumLength: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    minimumLength?: number | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "preference";
+                    allowTie: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    requireStrength?: boolean | undefined;
+                })[];
+            } | undefined;
+        } | {
+            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";
+            taskIds?: string[] | undefined;
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+        })[];
+        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;
+                };
+            }[];
+        };
+        publishedTasksetRef: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, unknown>;
+        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" | "feedback" | "messages" | "prompt" | "row_id" | "cluster_id" | "demonstration" | "chosen" | "rejected" | "expected_output" | "privileged_context" | "reward" | "tag";
+                    logicalType: "string" | "boolean" | "messages" | "integer" | "float" | "json";
+                    nullable: boolean;
+                    policy: "metadata" | "visible" | "privileged";
+                }[];
+                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;
+    };
+    files: {
+        path: string;
+        contentHash: string;
+        sizeBytes: number;
+        base64: string;
+    }[];
+    contentHash: string;
+};
+//# sourceMappingURL=dataset-preparation-workspace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-preparation-workspace.d.ts","sourceRoot":"","sources":["../../../../../src/dataset-preparation-workspace.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgE,KAAK,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAC5I,OAAO,EAAwE,KAAK,+BAA+B,EAAE,MAAM,yCAAyC,CAAC;AAErK,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;kFACkF;AAClF,wBAAgB,oCAAoC,CAAC,KAAK,EAAE;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,sBAAsB,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,aAAa,CAAC,EAAE,yBAAyB,EAAE,CAAC;IAC5C,cAAc,CAAC,EAAE,+BAA+B,GAAG,IAAI,CAAC;IACxD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFA"}