openpond-sdk 0.12.1 → 0.12.3

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

@@ -0,0 +1,364 @@
+import { type TasksetPackage } from "./taskset-package-contracts.js";
+import { buildTasksetTrainingBundle } from "./training-bundle.js";
+import { type ManagedTrainingPreparationInput } from "./managed-training-preparation.js";
+export type OrdinaryTasksetQualificationInput = Omit<Parameters<typeof buildTasksetTrainingBundle>[0], "taskset" | "executionMode" | "qualificationSource" | "tasksetRelease" | "rewardExecution" | "verifierAssets" | "tasksetAssetBytes" | "evaluationSource" | "approval"> & {
+    package: TasksetPackage;
+    approval: ManagedTrainingPreparationInput["approval"] & {
+        approvedAt: string;
+    };
+    idempotencyKey?: string;
+};
+/** Prepare a no-update original-learner run from the exact published ordinary
+ * package. Splits, families, task IDs and private grader bytes are preserved;
+ * this function does not create train/held-out data or approve any source. */
+export declare function prepareOrdinaryTasksetQualification(input: OrdinaryTasksetQualificationInput): Promise<{
+    bundle: import("./training-bundle.js").TasksetTrainingBundle;
+    artifact: {
+        schemaVersion: "openpond.trainingInputArtifactUpload.v2";
+        kind: "portable_training_bundle" | "reward_model_dataset";
+        idempotencyKey: string;
+        sourceManifest: {
+            id: string;
+            contentHash: string;
+        };
+        payload: unknown;
+        contentHash: string;
+    };
+    submission: {
+        schemaVersion: "openpond.trainingJobSubmission.v2";
+        idempotencyKey: string;
+        name: string;
+        source: {
+            modelProject: {
+                id: string;
+                portableProjectId: string;
+                revision: number;
+                contentHash: string;
+            };
+            harnessRunManifest: {
+                id: string;
+                contentHash: string;
+            };
+            harnessRelease: {
+                id: string;
+                contentHash: string;
+            };
+            taskset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            tasksetRelease: {
+                id: string;
+                contentHash: string;
+            };
+            dataset: {
+                id: string;
+                contentHash: string;
+            };
+            evidenceSets: {
+                id: string;
+                contentHash: string;
+            }[];
+            origin?: {
+                schemaVersion: "openpond.trainingHandoffOrigin.v1";
+                teamId: string;
+                projectId: string | null;
+                configurationId: string;
+                source: {
+                    executionId: string;
+                    passId: string | null;
+                    manifestHash: string;
+                    resultHash: string;
+                };
+                dataset: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                target: {
+                    kind: "model";
+                    modelId: string;
+                    configurationHash: string;
+                } | {
+                    kind: "harness";
+                    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;
+                    };
+                    model: {
+                        modelId: string;
+                        configurationHash: string;
+                    };
+                } | {
+                    kind: "agent";
+                    source: {
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        agentSnapshot: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        sourcePackageHash: string;
+                    };
+                    model: {
+                        modelId: string;
+                        configurationHash: string;
+                    };
+                } | {
+                    kind: "fixture";
+                    configurationHash: string;
+                };
+                graders: {
+                    feedbackKey: string;
+                    evaluator: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    expectedCount: number;
+                    scoredCount: number;
+                    score: number | null;
+                }[];
+                contentHash: string;
+            } | undefined;
+            evaluation?: {
+                taskset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                };
+            } | null | undefined;
+        };
+        job: {
+            kind: "reward_model_train";
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "local" | "managed" | "builtin";
+            };
+            preferenceDatasetRelease: {
+                id: string;
+                contentHash: string;
+            };
+            processorRelease: {
+                id: string;
+                contentHash: string;
+            };
+            recipe: {
+                [x: string]: unknown;
+                schemaVersion: "openpond.rewardModelRecipe.v1";
+                method: "reward_model";
+                parameterization: "lora_with_scalar_head";
+            };
+        } | {
+            kind: "policy_optimize";
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "local" | "managed" | "builtin";
+            };
+            recipe: {
+                [x: string]: unknown;
+                schemaVersion: string;
+                method: "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo";
+                parameterization: "lora" | "full";
+            };
+            rewardSource: {
+                kind: "deterministic";
+                grader: {
+                    id: string;
+                    contentHash: string;
+                };
+                composer: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+            } | {
+                kind: "learned_reward";
+                rewardModelVersion: {
+                    id: string;
+                    contentHash: string;
+                };
+                qualificationReport: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+                evaluationReferences: {
+                    id: string;
+                    contentHash: string;
+                }[];
+                scorerArtifact: {
+                    artifactRef: string;
+                    contentHash: string;
+                    executionReceipt: {
+                        id: string;
+                        contentHash: string;
+                    };
+                };
+                processorRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                rewardComposerRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+            };
+            resumeFrom: {
+                id: string;
+                contentHash: string;
+            } | null;
+            executionMode?: "qualification" | undefined;
+        };
+        requestedCapabilities: {
+            id: string;
+            version: string | null;
+            required: boolean;
+        }[];
+        placementObjective: "fast" | "balanced" | "economical";
+        budget: {
+            maximumSpendUsd: number;
+            maximumWallSeconds: number;
+        };
+        approval: {
+            approvalHash: string;
+            approvedAt: string;
+            exportApproved: boolean;
+            maximumSpendUsd: number;
+            retentionDays: number | null;
+            region: string | null;
+        };
+        contentHash: string;
+    };
+}>;
+//# sourceMappingURL=training-qualification-preparation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"training-qualification-preparation.d.ts","sourceRoot":"","sources":["../../../../../src/training-qualification-preparation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAoD,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEvH,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAoC,KAAK,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AAG3H,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC,CAAC,EACnG,SAAS,GAAG,eAAe,GAAG,qBAAqB,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,UAAU,CAAC,GAAG;IACzK,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,+BAA+B,CAAC,UAAU,CAAC,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;8EAE8E;AAC9E,wBAAsB,mCAAmC,CAAC,KAAK,EAAE,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDjG"}

package/dist/types/packages/sdk/src/training.d.ts

@@ -7,6 +7,7 @@ export { TrainingCandidateDecisionRequestSchema, TrainingCandidateDecisionSchema
 export { deterministicTrainingRewardSource } from "./training-grading-plan.js";
 export { TRAINING_EVALUATION_SOURCE_PATH, TrainingEvaluationSourceSchema, assertTrainingEvaluationIsolation, trainingEvaluationSourceRef, type TrainingEvaluationSource, } from "./training-evaluation-source.js";
 export { TrainingEvaluationTaskResultSchema, TrainingEvaluationTaskPageSchema, trainingEvaluationTaskPageHash, parseAndVerifyTrainingEvaluationTaskPage, type TrainingEvaluationTaskResult, type TrainingEvaluationTaskPage, } from "./training-evaluation-results.js";
+import { ModelProjectBaseModelSchema } from "./model-projects.js";
 export { OPENPOND_TRAINING_MEDIA_TYPE, OPENPOND_TRAINING_PROTOCOL_MAJOR, TRAINING_API_RESPONSE_MAX_BYTES, TRAINING_INPUT_ARTIFACT_MAX_BYTES, TRAINING_JOB_SUBMISSION_MAX_BYTES, OpenPondProtocolError, assertCanonicalPayloadSize, canonicalJson, canonicalJsonByteLength, canonicalSha256, parseBoundedJson, } from "./protocol.js";
 /**
  * Stages a content-addressed immutable input before Job admission. The payload
@@ -336,8 +337,22 @@ export declare const RewardModelTrainingRequestSchema: z.ZodObject<{
         parameterization: z.ZodLiteral<"lora_with_scalar_head">;
     }, z.core.$catchall<z.ZodUnknown>>;
 }, z.core.$strict>;
+export declare const TrainingQualificationBaseModelSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+    modelId: z.ZodString;
+    modelAssetId: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        local: "local";
+        managed: "managed";
+        builtin: "builtin";
+    }>;
+    revision: z.ZodString;
+    tokenizerRevision: z.ZodString;
+    chatTemplateHash: z.ZodString;
+}, z.core.$strict>;
 export declare const PolicyOptimizationRequestSchema: z.ZodObject<{
     kind: z.ZodLiteral<"policy_optimize">;
+    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
     baseModel: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
         modelId: z.ZodString;
@@ -444,6 +459,7 @@ export declare const TrainingJobRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     }, z.core.$catchall<z.ZodUnknown>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"policy_optimize">;
+    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
     baseModel: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
         modelId: z.ZodString;
@@ -804,6 +820,7 @@ export declare const TrainingJobSubmissionSchema: z.ZodObject<{
         }, z.core.$catchall<z.ZodUnknown>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"policy_optimize">;
+        executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
         baseModel: z.ZodObject<{
             schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
             modelId: z.ZodString;
@@ -914,6 +931,7 @@ export declare const TrainingJobSchema: z.ZodObject<{
         reward_model_train: "reward_model_train";
         policy_optimize: "policy_optimize";
     }>;
+    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
     modelProjectId: z.ZodString;
     portableProjectId: z.ZodString;
     sourceProjectRevision: z.ZodNumber;
@@ -954,6 +972,7 @@ export declare const TrainingJobPageSchema: z.ZodObject<{
             reward_model_train: "reward_model_train";
             policy_optimize: "policy_optimize";
         }>;
+        executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
         modelProjectId: z.ZodString;
         portableProjectId: z.ZodString;
         sourceProjectRevision: z.ZodNumber;
@@ -1032,6 +1051,38 @@ export declare const TrainingJobOutputSchema: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     createdAt: z.ZodString;
 }, z.core.$strict>;
+/** Evidence that collection used the pinned original learner and never updated it. */
+export declare const TrainingQualificationEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
+    baseModel: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            local: "local";
+            managed: "managed";
+            builtin: "builtin";
+        }>;
+        revision: z.ZodString;
+        tokenizerRevision: z.ZodString;
+        chatTemplateHash: z.ZodString;
+    }, z.core.$strict>;
+    group: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    rolloutReceipts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    rewardEvidenceHash: z.ZodString;
+    groupsCompleted: z.ZodLiteral<1>;
+    optimizerUpdatesApplied: z.ZodLiteral<0>;
+    optimizerUpdatesSkipped: z.ZodLiteral<0>;
+    trainingStepsCreated: z.ZodLiteral<0>;
+    checkpointsCreated: z.ZodLiteral<0>;
+    artifactsCreated: z.ZodLiteral<0>;
+}, z.core.$strict>;
 export declare const TrainingExecutionReceiptSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.trainingExecutionReceipt.v2">;
     id: z.ZodString;
@@ -1056,6 +1107,37 @@ export declare const TrainingExecutionReceiptSchema: z.ZodObject<{
     spendUsd: z.ZodNumber;
     durationSeconds: z.ZodNumber;
     cleanupComplete: z.ZodBoolean;
+    qualification: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                local: "local";
+                managed: "managed";
+                builtin: "builtin";
+            }>;
+            revision: z.ZodString;
+            tokenizerRevision: z.ZodString;
+            chatTemplateHash: z.ZodString;
+        }, z.core.$strict>;
+        group: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        rolloutReceipts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        rewardEvidenceHash: z.ZodString;
+        groupsCompleted: z.ZodLiteral<1>;
+        optimizerUpdatesApplied: z.ZodLiteral<0>;
+        optimizerUpdatesSkipped: z.ZodLiteral<0>;
+        trainingStepsCreated: z.ZodLiteral<0>;
+        checkpointsCreated: z.ZodLiteral<0>;
+        artifactsCreated: z.ZodLiteral<0>;
+    }, z.core.$strict>>;
     issuer: z.ZodString;
     issuedAt: z.ZodString;
     signature: z.ZodNullable<z.ZodString>;
@@ -1067,7 +1149,14 @@ export declare function parseAndVerifyTrainingExecutionReceipt(value: unknown, e
     teamId?: string;
     jobId?: string;
     requireCleanup?: boolean;
+    qualificationSubmission?: TrainingJobSubmission;
+    outputs?: TrainingJobOutput[];
 }): Promise<TrainingExecutionReceipt>;
+export declare function assertTrainingQualificationReceipt(receipt: TrainingExecutionReceipt, expected: {
+    submissionHash: string;
+    baseModel?: z.infer<typeof ModelProjectBaseModelSchema>;
+    outputs?: TrainingJobOutput[];
+}): Promise<void>;
 export declare const TrainingJobOutputsSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.trainingJobOutputs.v2">;
     outputs: z.ZodArray<z.ZodObject<{
@@ -1113,6 +1202,37 @@ export declare const TrainingJobOutputsSchema: z.ZodObject<{
         spendUsd: z.ZodNumber;
         durationSeconds: z.ZodNumber;
         cleanupComplete: z.ZodBoolean;
+        qualification: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
+            baseModel: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    local: "local";
+                    managed: "managed";
+                    builtin: "builtin";
+                }>;
+                revision: z.ZodString;
+                tokenizerRevision: z.ZodString;
+                chatTemplateHash: z.ZodString;
+            }, z.core.$strict>;
+            group: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            rolloutReceipts: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            rewardEvidenceHash: z.ZodString;
+            groupsCompleted: z.ZodLiteral<1>;
+            optimizerUpdatesApplied: z.ZodLiteral<0>;
+            optimizerUpdatesSkipped: z.ZodLiteral<0>;
+            trainingStepsCreated: z.ZodLiteral<0>;
+            checkpointsCreated: z.ZodLiteral<0>;
+            artifactsCreated: z.ZodLiteral<0>;
+        }, z.core.$strict>>;
         issuer: z.ZodString;
         issuedAt: z.ZodString;
         signature: z.ZodNullable<z.ZodString>;
@@ -1142,6 +1262,10 @@ export declare const TrainingCapabilitiesSchema: z.ZodObject<{
         policy_optimize: "policy_optimize";
     }>>;
     methods: z.ZodArray<z.ZodString>;
+    executionModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        training: "training";
+        qualification: "qualification";
+    }>>>;
     placements: z.ZodArray<z.ZodEnum<{
         local: "local";
         remote: "remote";
@@ -1162,6 +1286,7 @@ export declare const TrainingCapabilitiesSchema: z.ZodObject<{
     expiresAt: z.ZodString;
 }, z.core.$strict>;
 export type TrainingJobSubmission = z.infer<typeof TrainingJobSubmissionSchema>;
+export type TrainingQualificationEvidence = z.infer<typeof TrainingQualificationEvidenceSchema>;
 export type TrainingInputArtifactUpload = z.infer<typeof TrainingInputArtifactUploadSchema>;
 export type TrainingInputArtifact = z.infer<typeof TrainingInputArtifactSchema>;
 export type TrainingJob = z.infer<typeof TrainingJobSchema>;
@@ -1195,6 +1320,7 @@ export declare function createTrainingClient(input: {
         };
         checkedAt: string;
         expiresAt: string;
+        executionModes?: ("training" | "qualification")[] | undefined;
     }>;
     stageArtifact(upload: TrainingInputArtifactUpload): Promise<{
         schemaVersion: "openpond.trainingInputArtifact.v2";
@@ -1232,6 +1358,7 @@ export declare function createTrainingClient(input: {
         createdAt: string;
         updatedAt: string;
         completedAt: string | null;
+        executionMode?: "qualification" | undefined;
     }>;
     listJobs(options?: {
         modelProjectId?: string;
@@ -1263,6 +1390,7 @@ export declare function createTrainingClient(input: {
             createdAt: string;
             updatedAt: string;
             completedAt: string | null;
+            executionMode?: "qualification" | undefined;
         }[];
         nextCursor: string | null;
     }>;
@@ -1290,6 +1418,7 @@ export declare function createTrainingClient(input: {
         createdAt: string;
         updatedAt: string;
         completedAt: string | null;
+        executionMode?: "qualification" | undefined;
     }>;
     cancelJob(jobId: string, expectedVersion: number): Promise<{
         schemaVersion: "openpond.trainingJob.v2";
@@ -1315,6 +1444,7 @@ export declare function createTrainingClient(input: {
         createdAt: string;
         updatedAt: string;
         completedAt: string | null;
+        executionMode?: "qualification" | undefined;
     }>;
     stopAfterGroup(jobId: string, expectedVersion: number): Promise<{
         schemaVersion: "openpond.trainingJob.v2";
@@ -1340,6 +1470,7 @@ export declare function createTrainingClient(input: {
         createdAt: string;
         updatedAt: string;
         completedAt: string | null;
+        executionMode?: "qualification" | undefined;
     }>;
     events(jobId: string): Promise<{
         schemaVersion: "openpond.trainingJobEvent.v2";
@@ -1392,6 +1523,33 @@ export declare function createTrainingClient(input: {
             issuer: string;
             issuedAt: string;
             signature: string | null;
+            qualification?: {
+                schemaVersion: "openpond.trainingQualificationEvidence.v1";
+                baseModel: {
+                    schemaVersion: "openpond.baseModelPreference.v1";
+                    modelId: string;
+                    modelAssetId: string | null;
+                    source: "local" | "managed" | "builtin";
+                    revision: string;
+                    tokenizerRevision: string;
+                    chatTemplateHash: string;
+                };
+                group: {
+                    id: string;
+                    contentHash: string;
+                };
+                rolloutReceipts: {
+                    id: string;
+                    contentHash: string;
+                }[];
+                rewardEvidenceHash: string;
+                groupsCompleted: 1;
+                optimizerUpdatesApplied: 0;
+                optimizerUpdatesSkipped: 0;
+                trainingStepsCreated: 0;
+                checkpointsCreated: 0;
+                artifactsCreated: 0;
+            } | undefined;
         } | null;
     }>;
     evaluationTasks(jobId: string, evaluation: {
@@ -4226,6 +4384,9 @@ export declare function createTrainingClient(input: {
                                 };
                                 modelConfigurationHash: string;
                                 packageHash: string;
+                                maxOutputTokens?: number | undefined;
+                                temperature?: number | undefined;
+                                topP?: number | undefined;
                                 candidate?: {
                                     artifactId: string;
                                     contentHash: string;