openpond-sdk 0.9.9 → 0.11.0

package/dist/types/packages/sdk/src/profile-evaluation-discovery.d.ts

@@ -0,0 +1,1127 @@
+import { z } from "zod";
+export declare const ProfileEvaluationDiscoverySchema: z.ZodObject<{
+    profileRef: z.ZodObject<{
+        source: z.ZodEnum<{
+            local: "local";
+            github: "github";
+            openpond_git: "openpond_git";
+        }>;
+        repositoryId: z.ZodString;
+        profileId: z.ZodString;
+    }, z.core.$strict>;
+    sourceRevision: z.ZodString;
+    harnessRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    catalogHash: z.ZodNullable<z.ZodString>;
+    definitions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"profile">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"workflow">;
+            workflowId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"skill">;
+            skillPath: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent_action">;
+            actionId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        tasksetRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        split: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        taskIds: z.ZodArray<z.ZodString>;
+        seeds: z.ZodArray<z.ZodString>;
+        criterion: z.ZodObject<{
+            minimumPassRate: z.ZodNumber;
+            requireComplete: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    suites: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        scope: z.ZodEnum<{
+            profile: "profile";
+            component: "component";
+        }>;
+        definitionIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    runs: z.ZodArray<z.ZodObject<{
+        profileRef: z.ZodObject<{
+            source: z.ZodEnum<{
+                local: "local";
+                github: "github";
+                openpond_git: "openpond_git";
+            }>;
+            repositoryId: z.ZodString;
+            profileId: z.ZodString;
+        }, z.core.$strict>;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.tasksetRunManifest.v1">;
+            id: z.ZodString;
+            tasksetRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            packageHash: z.ZodString;
+            execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"taskset">;
+                environmentRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                verifierSetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                policyHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"harness">;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "kind">;
+            profileEvaluation: z.ZodOptional<z.ZodObject<{
+                profileId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                definitionHash: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                environmentHash: z.ZodString;
+                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                    dataset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    packageHash: z.ZodString;
+                    profileId: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                    protectedProfileClosureHash: z.ZodString;
+                    recordedOrigin: z.ZodOptional<z.ZodObject<{
+                        execution: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        originalEvidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        members: z.ZodArray<z.ZodObject<{
+                            caseId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodString;
+                            sourceId: z.ZodString;
+                            snapshotHash: z.ZodString;
+                            boundaryRevisionHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    gradingSource: z.ZodOptional<z.ZodObject<{
+                        pass: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        evidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>>;
+                    split: z.ZodEnum<{
+                        train: "train";
+                        validation: "validation";
+                        test: "test";
+                        frozen_eval: "frozen_eval";
+                    }>;
+                    population: z.ZodArray<z.ZodObject<{
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    evaluators: z.ZodArray<z.ZodObject<{
+                        release: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                        }, z.core.$strict>;
+                        feedbackKey: z.ZodString;
+                        configurationHash: z.ZodString;
+                        output: z.ZodEnum<{
+                            boolean: "boolean";
+                            score: "score";
+                            category: "category";
+                        }>;
+                        categories: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                    fieldMappingsHash: z.ZodString;
+                    fieldMappings: z.ZodArray<z.ZodObject<{
+                        graderId: z.ZodString;
+                        fields: z.ZodArray<z.ZodObject<{
+                            destination: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                            source: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            sourcePath: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    environmentHash: z.ZodString;
+                    privateDatasetClosureHash: z.ZodString;
+                    criterion: z.ZodObject<{
+                        minimumPassRate: z.ZodNumber;
+                        requireComplete: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                sourceCandidate: z.ZodOptional<z.ZodObject<{
+                    candidateId: z.ZodString;
+                    frozenRevision: z.ZodNumber;
+                    frozenHash: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    protectedClosureHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"model">;
+                model: z.ZodObject<{
+                    provider: z.ZodString;
+                    model: z.ZodString;
+                    revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    artifactHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    tokenizerRevision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    chatTemplateHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixture">;
+            }, z.core.$strict>], "kind">;
+            gradingRole: z.ZodLiteral<"evaluation">;
+            metricPolicy: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
+                primaryMetric: z.ZodString;
+                aggregation: z.ZodEnum<{
+                    mean_score: "mean_score";
+                    pass_rate: "pass_rate";
+                    weighted_mean: "weighted_mean";
+                    custom: "custom";
+                }>;
+                missingReward: z.ZodEnum<{
+                    zero: "zero";
+                    exclude: "exclude";
+                }>;
+                taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                customAggregator: z.ZodNullable<z.ZodObject<{
+                    module: z.ZodString;
+                    exportName: z.ZodString;
+                    contentHash: z.ZodString;
+                    timeoutMs: z.ZodNumber;
+                    networkPolicy: z.ZodLiteral<"none">;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            population: z.ZodArray<z.ZodObject<{
+                receiptId: z.ZodString;
+                taskId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            runtimeTarget: z.ZodObject<{
+                adapterId: z.ZodString;
+                placement: z.ZodEnum<{
+                    local: "local";
+                    remote: "remote";
+                    colocated: "colocated";
+                    provider_native: "provider_native";
+                }>;
+                runtimeVersion: z.ZodString;
+                capabilityReceipt: z.ZodString;
+            }, z.core.$strict>;
+            limits: z.ZodObject<{
+                maxTurns: z.ZodNumber;
+                timeoutMs: z.ZodNumber;
+                maxOutputBytes: z.ZodNumber;
+                maximumSpendUsd: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+            createdAt: z.ZodString;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        metric: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.tasksetMetricResult.v1">;
+            runManifest: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            tasksetRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            policy: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
+                primaryMetric: z.ZodString;
+                aggregation: z.ZodEnum<{
+                    mean_score: "mean_score";
+                    pass_rate: "pass_rate";
+                    weighted_mean: "weighted_mean";
+                    custom: "custom";
+                }>;
+                missingReward: z.ZodEnum<{
+                    zero: "zero";
+                    exclude: "exclude";
+                }>;
+                taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                customAggregator: z.ZodNullable<z.ZodObject<{
+                    module: z.ZodString;
+                    exportName: z.ZodString;
+                    contentHash: z.ZodString;
+                    timeoutMs: z.ZodNumber;
+                    networkPolicy: z.ZodLiteral<"none">;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            policyHash: z.ZodString;
+            receiptRefs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            includedCount: z.ZodNumber;
+            missingRewardCount: z.ZodNumber;
+            excludedCount: z.ZodNumber;
+            value: z.ZodNullable<z.ZodNumber>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        gradeRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        receiptRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        passRate: z.ZodNumber;
+        passed: z.ZodBoolean;
+        completedAt: z.ZodISODateTime;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    comparisons: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.profileEvaluationComparison.v1">;
+        id: z.ZodString;
+        tasksetRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        populationHash: z.ZodString;
+        environmentHash: z.ZodString;
+        metricPolicyHash: z.ZodString;
+        limitsHash: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            runManifest: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            metricResultHash: z.ZodString;
+            source: z.ZodObject<{
+                profileId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                definitionHash: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                environmentHash: z.ZodString;
+                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                    dataset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    packageHash: z.ZodString;
+                    profileId: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                    protectedProfileClosureHash: z.ZodString;
+                    recordedOrigin: z.ZodOptional<z.ZodObject<{
+                        execution: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        originalEvidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        members: z.ZodArray<z.ZodObject<{
+                            caseId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodString;
+                            sourceId: z.ZodString;
+                            snapshotHash: z.ZodString;
+                            boundaryRevisionHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    gradingSource: z.ZodOptional<z.ZodObject<{
+                        pass: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        evidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>>;
+                    split: z.ZodEnum<{
+                        train: "train";
+                        validation: "validation";
+                        test: "test";
+                        frozen_eval: "frozen_eval";
+                    }>;
+                    population: z.ZodArray<z.ZodObject<{
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    evaluators: z.ZodArray<z.ZodObject<{
+                        release: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                        }, z.core.$strict>;
+                        feedbackKey: z.ZodString;
+                        configurationHash: z.ZodString;
+                        output: z.ZodEnum<{
+                            boolean: "boolean";
+                            score: "score";
+                            category: "category";
+                        }>;
+                        categories: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                    fieldMappingsHash: z.ZodString;
+                    fieldMappings: z.ZodArray<z.ZodObject<{
+                        graderId: z.ZodString;
+                        fields: z.ZodArray<z.ZodObject<{
+                            destination: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                            source: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            sourcePath: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    environmentHash: z.ZodString;
+                    privateDatasetClosureHash: z.ZodString;
+                    criterion: z.ZodObject<{
+                        minimumPassRate: z.ZodNumber;
+                        requireComplete: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                sourceCandidate: z.ZodOptional<z.ZodObject<{
+                    candidateId: z.ZodString;
+                    frozenRevision: z.ZodNumber;
+                    frozenHash: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    protectedClosureHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"model">;
+                model: z.ZodObject<{
+                    provider: z.ZodString;
+                    model: z.ZodString;
+                    revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    artifactHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    tokenizerRevision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    chatTemplateHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixture">;
+            }, z.core.$strict>], "kind">;
+            score: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    suiteRuns: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.profileEvaluationSuiteRun.v1">;
+        id: z.ZodString;
+        suiteId: z.ZodString;
+        suiteHash: z.ZodString;
+        catalogHash: z.ZodString;
+        profileId: z.ZodString;
+        sourceRevision: z.ZodString;
+        harnessRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        members: z.ZodArray<z.ZodObject<{
+            definitionId: z.ZodString;
+            runManifest: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            runHash: z.ZodString;
+            passed: z.ZodBoolean;
+            score: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        passed: z.ZodBoolean;
+        createdAt: z.ZodString;
+        completedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    reports: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.profileEvaluationReport.v1">;
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        testedSources: z.ZodArray<z.ZodObject<{
+            profileId: z.ZodString;
+            sourceRevision: z.ZodString;
+            harnessRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        tasksetReleases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        metricPolicyHashes: z.ZodArray<z.ZodString>;
+        modelConfigurationHashes: z.ZodArray<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                run: "run";
+                suite: "suite";
+                comparison: "comparison";
+            }>;
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        summary: z.ZodObject<{
+            totalChecks: z.ZodNumber;
+            passedChecks: z.ZodNumber;
+            failedChecks: z.ZodNumber;
+            unscoredChecks: z.ZodNumber;
+            meanScore: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProfileEvaluationDiscovery = z.infer<typeof ProfileEvaluationDiscoverySchema>;
+export declare const ProfileEvaluationDiscoveryRequestSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    profileRepositoryId: z.ZodString;
+    trainingProjectId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Reads the existing source owner's receipts. No resource is copied and no
+ * incomplete execution is turned into a synthetic rerunnable configuration. */
+export declare class OpenPondProfileEvaluationDiscoveryClient {
+    private readonly options;
+    constructor(options: {
+        baseUrl: string;
+        apiKey: string;
+        teamId: string;
+        fetch?: typeof fetch;
+    });
+    read(input: {
+        profileRepositoryId: string;
+        trainingProjectId?: string;
+    }, signal?: AbortSignal): Promise<{
+        profileRef: {
+            source: "local" | "github" | "openpond_git";
+            repositoryId: string;
+            profileId: string;
+        };
+        sourceRevision: string;
+        harnessRelease: {
+            id: string;
+            contentHash: string;
+        };
+        catalogHash: string | null;
+        definitions: {
+            id: string;
+            label: string;
+            description: string;
+            target: {
+                kind: "profile";
+            } | {
+                kind: "workflow";
+                workflowId: string;
+            } | {
+                kind: "skill";
+                skillPath: string;
+            } | {
+                kind: "agent_action";
+                actionId: string;
+            };
+            tasksetRelease: {
+                id: string;
+                contentHash: string;
+            };
+            split: "train" | "validation" | "test" | "frozen_eval";
+            taskIds: string[];
+            seeds: string[];
+            criterion: {
+                minimumPassRate: number;
+                requireComplete: boolean;
+            };
+        }[];
+        suites: {
+            id: string;
+            label: string;
+            scope: "component" | "profile";
+            definitionIds: string[];
+        }[];
+        runs: {
+            profileRef: {
+                source: "local" | "github" | "openpond_git";
+                repositoryId: string;
+                profileId: string;
+            };
+            manifest: {
+                schemaVersion: "openpond.tasksetRunManifest.v1";
+                id: string;
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                packageHash: string;
+                execution: {
+                    kind: "taskset";
+                    environmentRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    verifierSetRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    policyHash: string;
+                } | {
+                    kind: "harness";
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                };
+                policy: {
+                    kind: "model";
+                    model: {
+                        provider: string;
+                        model: string;
+                        revision: string | null;
+                        artifactHash: string | null;
+                        tokenizerRevision: string | null;
+                        chatTemplateHash: string | null;
+                    };
+                    configurationHash: string;
+                } | {
+                    kind: "fixture";
+                };
+                gradingRole: "evaluation";
+                metricPolicy: {
+                    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;
+                };
+                population: {
+                    receiptId: string;
+                    taskId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                }[];
+                runtimeTarget: {
+                    adapterId: string;
+                    placement: "local" | "remote" | "colocated" | "provider_native";
+                    runtimeVersion: string;
+                    capabilityReceipt: string;
+                };
+                limits: {
+                    maxTurns: number;
+                    timeoutMs: number;
+                    maxOutputBytes: number;
+                    maximumSpendUsd: number | null;
+                };
+                createdAt: string;
+                metadata: Record<string, unknown>;
+                contentHash: string;
+                profileEvaluation?: {
+                    profileId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    catalogHash: string;
+                    definitionId: string;
+                    definitionHash: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    environmentHash: string;
+                    externalDatasetBinding?: {
+                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                        dataset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        packageHash: string;
+                        profileId: string;
+                        target: {
+                            kind: "profile";
+                        } | {
+                            kind: "workflow";
+                            workflowId: string;
+                        } | {
+                            kind: "skill";
+                            skillPath: string;
+                        } | {
+                            kind: "agent_action";
+                            actionId: string;
+                        };
+                        declaredProfileCatalogHash: string | null;
+                        protectedProfileClosureHash: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        population: {
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        evaluators: {
+                            release: {
+                                id: string;
+                                contentHash: string;
+                                revision: string | number;
+                            };
+                            feedbackKey: string;
+                            configurationHash: string;
+                            output: "boolean" | "score" | "category";
+                            categories: string[];
+                        }[];
+                        fieldMappingsHash: string;
+                        fieldMappings: {
+                            graderId: string;
+                            fields: {
+                                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                path: string[];
+                                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                sourcePath: string[];
+                            }[];
+                        }[];
+                        environmentHash: string;
+                        privateDatasetClosureHash: string;
+                        criterion: {
+                            minimumPassRate: number;
+                            requireComplete: boolean;
+                        };
+                        contentHash: string;
+                        recordedOrigin?: {
+                            execution: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            originalEvidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            members: {
+                                caseId: string;
+                                seed: string;
+                                fixtureId: string;
+                                sourceId: string;
+                                snapshotHash: string;
+                                boundaryRevisionHash: string;
+                            }[];
+                        } | undefined;
+                        gradingSource?: {
+                            pass: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            evidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
+                    } | undefined;
+                    sourceCandidate?: {
+                        candidateId: string;
+                        frozenRevision: number;
+                        frozenHash: string;
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        protectedClosureHash: string;
+                    } | undefined;
+                } | undefined;
+            };
+            metric: {
+                schemaVersion: "openpond.tasksetMetricResult.v1";
+                runManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                policy: {
+                    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;
+                };
+                policyHash: string;
+                receiptRefs: {
+                    id: string;
+                    contentHash: string;
+                }[];
+                includedCount: number;
+                missingRewardCount: number;
+                excludedCount: number;
+                value: number | null;
+                contentHash: string;
+            };
+            gradeRefs: {
+                id: string;
+                contentHash: string;
+            }[];
+            receiptRefs: {
+                id: string;
+                contentHash: string;
+            }[];
+            passRate: number;
+            passed: boolean;
+            completedAt: string;
+            contentHash: string;
+        }[];
+        comparisons: {
+            schemaVersion: "openpond.profileEvaluationComparison.v1";
+            id: string;
+            tasksetRelease: {
+                id: string;
+                contentHash: string;
+            };
+            populationHash: string;
+            environmentHash: string;
+            metricPolicyHash: string;
+            limitsHash: string;
+            members: {
+                runManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                metricResultHash: string;
+                source: {
+                    profileId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    catalogHash: string;
+                    definitionId: string;
+                    definitionHash: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    environmentHash: string;
+                    externalDatasetBinding?: {
+                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                        dataset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        packageHash: string;
+                        profileId: string;
+                        target: {
+                            kind: "profile";
+                        } | {
+                            kind: "workflow";
+                            workflowId: string;
+                        } | {
+                            kind: "skill";
+                            skillPath: string;
+                        } | {
+                            kind: "agent_action";
+                            actionId: string;
+                        };
+                        declaredProfileCatalogHash: string | null;
+                        protectedProfileClosureHash: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        population: {
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        evaluators: {
+                            release: {
+                                id: string;
+                                contentHash: string;
+                                revision: string | number;
+                            };
+                            feedbackKey: string;
+                            configurationHash: string;
+                            output: "boolean" | "score" | "category";
+                            categories: string[];
+                        }[];
+                        fieldMappingsHash: string;
+                        fieldMappings: {
+                            graderId: string;
+                            fields: {
+                                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                path: string[];
+                                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                sourcePath: string[];
+                            }[];
+                        }[];
+                        environmentHash: string;
+                        privateDatasetClosureHash: string;
+                        criterion: {
+                            minimumPassRate: number;
+                            requireComplete: boolean;
+                        };
+                        contentHash: string;
+                        recordedOrigin?: {
+                            execution: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            originalEvidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            members: {
+                                caseId: string;
+                                seed: string;
+                                fixtureId: string;
+                                sourceId: string;
+                                snapshotHash: string;
+                                boundaryRevisionHash: string;
+                            }[];
+                        } | undefined;
+                        gradingSource?: {
+                            pass: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            evidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
+                    } | undefined;
+                    sourceCandidate?: {
+                        candidateId: string;
+                        frozenRevision: number;
+                        frozenHash: string;
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        protectedClosureHash: string;
+                    } | undefined;
+                };
+                policy: {
+                    kind: "model";
+                    model: {
+                        provider: string;
+                        model: string;
+                        revision: string | null;
+                        artifactHash: string | null;
+                        tokenizerRevision: string | null;
+                        chatTemplateHash: string | null;
+                    };
+                    configurationHash: string;
+                } | {
+                    kind: "fixture";
+                };
+                score: number | null;
+            }[];
+            createdAt: string;
+            contentHash: string;
+        }[];
+        suiteRuns: {
+            schemaVersion: "openpond.profileEvaluationSuiteRun.v1";
+            id: string;
+            suiteId: string;
+            suiteHash: string;
+            catalogHash: string;
+            profileId: string;
+            sourceRevision: string;
+            harnessRelease: {
+                id: string;
+                contentHash: string;
+            };
+            members: {
+                definitionId: string;
+                runManifest: {
+                    id: string;
+                    contentHash: string;
+                };
+                runHash: string;
+                passed: boolean;
+                score: number | null;
+            }[];
+            passed: boolean;
+            createdAt: string;
+            completedAt: string;
+            contentHash: string;
+        }[];
+        reports: {
+            schemaVersion: "openpond.profileEvaluationReport.v1";
+            id: string;
+            createdAt: string;
+            testedSources: {
+                profileId: string;
+                sourceRevision: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+            }[];
+            tasksetReleases: {
+                id: string;
+                contentHash: string;
+            }[];
+            metricPolicyHashes: string[];
+            modelConfigurationHashes: string[];
+            evidence: {
+                kind: "run" | "comparison" | "suite";
+                id: string;
+                contentHash: string;
+            }[];
+            summary: {
+                totalChecks: number;
+                passedChecks: number;
+                failedChecks: number;
+                unscoredChecks: number;
+                meanScore: number | null;
+            };
+            contentHash: string;
+        }[];
+    }>;
+}
+//# sourceMappingURL=profile-evaluation-discovery.d.ts.map