import { z } from "zod";
export { EvaluationProjectContextSchema, EvaluationMessagesSchema, type EvaluationProjectContext } from "./evaluation-project-context.js";
export declare const ModelStarterAttemptPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    kind: z.ZodLiteral<"hosted_chat">;
    modelId: z.ZodString;
    localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
        providerId: z.ZodLiteral<"custom-openai-compatible">;
        configurationHash: z.ZodString;
        maximumRequestCostUsd: z.ZodNumber;
        requestTimeoutMs: z.ZodNumber;
    }, z.core.$strict>, z.ZodObject<{
        providerId: z.ZodLiteral<"claude-code">;
        configurationHash: z.ZodString;
        executableHash: z.ZodString;
        version: z.ZodString;
        capabilityHash: z.ZodString;
        maximumRequestCostUsd: z.ZodNumber;
        requestTimeoutMs: z.ZodNumber;
        maximumTurns: z.ZodNumber;
        holdOpen: z.ZodBoolean;
    }, z.core.$strict>, z.ZodObject<{
        providerId: z.ZodLiteral<"codex">;
        configurationHash: z.ZodString;
        accountHash: z.ZodString;
        reasoningEffort: z.ZodEnum<{
            high: "high";
            low: "low";
            medium: "medium";
            xhigh: "xhigh";
        }>;
        maximumRequestCostUsd: z.ZodNumber;
        requestTimeoutMs: z.ZodNumber;
    }, z.core.$strict>]>>;
    candidate: z.ZodOptional<z.ZodObject<{
        artifactId: z.ZodString;
        contentHash: z.ZodString;
        preparationId: z.ZodString;
        dispatchId: z.ZodString;
        baseProfileId: z.ZodString;
        workerImageDigest: z.ZodString;
    }, z.core.$strict>>;
    harness: z.ZodOptional<z.ZodObject<{
        harnessRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        agentSnapshot: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        sourcePackageHash: z.ZodString;
    }, z.core.$strict>>;
    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<{
            assistant: "assistant";
            system: "system";
            user: "user";
        }>;
        content: z.ZodString;
    }, z.core.$strict>>>;
    maxOutputTokens: z.ZodDefault<z.ZodNumber>;
    temperature: z.ZodDefault<z.ZodNumber>;
    topP: z.ZodDefault<z.ZodNumber>;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"fixture">;
    fixtureId: z.ZodString;
}, z.core.$strict>], "kind">;
/** The server resolves task input, private state, verifier and fixture script.
 * A caller can select releases, but cannot submit replacement execution bytes. */
export declare const ModelStarterAttemptRequestSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptRequest.v1">;
    operationId: z.ZodString;
    teamId: z.ZodString;
    modelProjectId: z.ZodNullable<z.ZodString>;
    project: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        revision: z.ZodNumber;
        contentHash: z.ZodString;
        targetId: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
    taskset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    taskId: z.ZodString;
    environmentSeed: z.ZodDefault<z.ZodNumber>;
    policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"hosted_chat">;
        modelId: z.ZodString;
        localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
            providerId: z.ZodLiteral<"custom-openai-compatible">;
            configurationHash: z.ZodString;
            maximumRequestCostUsd: z.ZodNumber;
            requestTimeoutMs: z.ZodNumber;
        }, z.core.$strict>, z.ZodObject<{
            providerId: z.ZodLiteral<"claude-code">;
            configurationHash: z.ZodString;
            executableHash: z.ZodString;
            version: z.ZodString;
            capabilityHash: z.ZodString;
            maximumRequestCostUsd: z.ZodNumber;
            requestTimeoutMs: z.ZodNumber;
            maximumTurns: z.ZodNumber;
            holdOpen: z.ZodBoolean;
        }, z.core.$strict>, z.ZodObject<{
            providerId: z.ZodLiteral<"codex">;
            configurationHash: z.ZodString;
            accountHash: z.ZodString;
            reasoningEffort: z.ZodEnum<{
                high: "high";
                low: "low";
                medium: "medium";
                xhigh: "xhigh";
            }>;
            maximumRequestCostUsd: z.ZodNumber;
            requestTimeoutMs: z.ZodNumber;
        }, z.core.$strict>]>>;
        candidate: z.ZodOptional<z.ZodObject<{
            artifactId: z.ZodString;
            contentHash: z.ZodString;
            preparationId: z.ZodString;
            dispatchId: z.ZodString;
            baseProfileId: z.ZodString;
            workerImageDigest: z.ZodString;
        }, z.core.$strict>>;
        harness: z.ZodOptional<z.ZodObject<{
            harnessRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            agentSnapshot: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            sourcePackageHash: z.ZodString;
        }, z.core.$strict>>;
        messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<{
                assistant: "assistant";
                system: "system";
                user: "user";
            }>;
            content: z.ZodString;
        }, z.core.$strict>>>;
        maxOutputTokens: z.ZodDefault<z.ZodNumber>;
        temperature: z.ZodDefault<z.ZodNumber>;
        topP: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"fixture">;
        fixtureId: z.ZodString;
    }, z.core.$strict>], "kind">;
}, z.core.$strict>;
export type ModelStarterAttemptRequest = z.infer<typeof ModelStarterAttemptRequestSchema>;
export declare const ModelStarterAttemptChoicesQuerySchema: z.ZodObject<{
    modelProjectId: z.ZodNullable<z.ZodString>;
    taskset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    afterTaskId: z.ZodOptional<z.ZodString>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strict>;
export declare const ModelStarterAttemptChoicesSchema: z.ZodObject<{
    modelProjectId: z.ZodNullable<z.ZodString>;
    taskset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    available: z.ZodBoolean;
    unavailableReason: z.ZodNullable<z.ZodString>;
    models: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        maximumOutputTokens: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strict>>;
    tasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        split: z.ZodEnum<{
            frozen_eval: "frozen_eval";
            test: "test";
            train: "train";
            validation: "validation";
        }>;
        inputPreview: z.ZodString;
        fixtures: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            label: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    nextCursor: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare const ModelStarterAttemptSummarySchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptSummary.v1">;
    id: z.ZodString;
    revision: z.ZodNumber;
    request: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptRequest.v1">;
        operationId: z.ZodString;
        teamId: z.ZodString;
        modelProjectId: z.ZodNullable<z.ZodString>;
        project: z.ZodOptional<z.ZodObject<{
            id: z.ZodString;
            revision: z.ZodNumber;
            contentHash: z.ZodString;
            targetId: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>;
        taskset: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        taskId: z.ZodString;
        environmentSeed: z.ZodDefault<z.ZodNumber>;
        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"hosted_chat">;
            modelId: z.ZodString;
            localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                providerId: z.ZodLiteral<"custom-openai-compatible">;
                configurationHash: z.ZodString;
                maximumRequestCostUsd: z.ZodNumber;
                requestTimeoutMs: z.ZodNumber;
            }, z.core.$strict>, z.ZodObject<{
                providerId: z.ZodLiteral<"claude-code">;
                configurationHash: z.ZodString;
                executableHash: z.ZodString;
                version: z.ZodString;
                capabilityHash: z.ZodString;
                maximumRequestCostUsd: z.ZodNumber;
                requestTimeoutMs: z.ZodNumber;
                maximumTurns: z.ZodNumber;
                holdOpen: z.ZodBoolean;
            }, z.core.$strict>, z.ZodObject<{
                providerId: z.ZodLiteral<"codex">;
                configurationHash: z.ZodString;
                accountHash: z.ZodString;
                reasoningEffort: z.ZodEnum<{
                    high: "high";
                    low: "low";
                    medium: "medium";
                    xhigh: "xhigh";
                }>;
                maximumRequestCostUsd: z.ZodNumber;
                requestTimeoutMs: z.ZodNumber;
            }, z.core.$strict>]>>;
            candidate: z.ZodOptional<z.ZodObject<{
                artifactId: z.ZodString;
                contentHash: z.ZodString;
                preparationId: z.ZodString;
                dispatchId: z.ZodString;
                baseProfileId: z.ZodString;
                workerImageDigest: z.ZodString;
            }, z.core.$strict>>;
            harness: z.ZodOptional<z.ZodObject<{
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                agentSnapshot: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                sourcePackageHash: z.ZodString;
            }, z.core.$strict>>;
            messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
                role: z.ZodEnum<{
                    assistant: "assistant";
                    system: "system";
                    user: "user";
                }>;
                content: z.ZodString;
            }, z.core.$strict>>>;
            maxOutputTokens: z.ZodDefault<z.ZodNumber>;
            temperature: z.ZodDefault<z.ZodNumber>;
            topP: z.ZodDefault<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"fixture">;
            fixtureId: z.ZodString;
        }, z.core.$strict>], "kind">;
    }, z.core.$strict>;
    status: z.ZodEnum<{
        cancelled: "cancelled";
        cancelling: "cancelling";
        completed: "completed";
        failed: "failed";
        queued: "queued";
        running: "running";
    }>;
    policySnapshot: z.ZodNullable<z.ZodObject<{
        modelId: z.ZodString;
        provider: z.ZodString;
        upstreamModelId: z.ZodString;
        configurationHash: z.ZodString;
    }, z.core.$strict>>;
    createdAt: z.ZodISODateTime;
    startedAt: z.ZodNullable<z.ZodISODateTime>;
    completedAt: z.ZodNullable<z.ZodISODateTime>;
    cleanupComplete: z.ZodBoolean;
    resultAvailable: z.ZodBoolean;
    score: z.ZodNullable<z.ZodNumber>;
    gradingStatus: z.ZodDefault<z.ZodEnum<{
        not_configured: "not_configured";
        not_started: "not_started";
        pending: "pending";
        scored: "scored";
        unscorable: "unscorable";
    }>>;
    passed: z.ZodNullable<z.ZodBoolean>;
    outputPreview: z.ZodNullable<z.ZodString>;
    error: z.ZodNullable<z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ModelStarterAttemptSummary = z.infer<typeof ModelStarterAttemptSummarySchema>;
export declare const ModelStarterAttemptListQuerySchema: z.ZodObject<{
    modelProjectId: z.ZodString;
    afterId: z.ZodOptional<z.ZodString>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strict>;
export declare const ModelStarterAttemptPageSchema: z.ZodObject<{
    items: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptSummary.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        request: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptRequest.v1">;
            operationId: z.ZodString;
            teamId: z.ZodString;
            modelProjectId: z.ZodNullable<z.ZodString>;
            project: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
                targetId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            taskId: z.ZodString;
            environmentSeed: z.ZodDefault<z.ZodNumber>;
            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"hosted_chat">;
                modelId: z.ZodString;
                localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                    providerId: z.ZodLiteral<"custom-openai-compatible">;
                    configurationHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"claude-code">;
                    configurationHash: z.ZodString;
                    executableHash: z.ZodString;
                    version: z.ZodString;
                    capabilityHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                    maximumTurns: z.ZodNumber;
                    holdOpen: z.ZodBoolean;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"codex">;
                    configurationHash: z.ZodString;
                    accountHash: z.ZodString;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        medium: "medium";
                        xhigh: "xhigh";
                    }>;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>]>>;
                candidate: z.ZodOptional<z.ZodObject<{
                    artifactId: z.ZodString;
                    contentHash: z.ZodString;
                    preparationId: z.ZodString;
                    dispatchId: z.ZodString;
                    baseProfileId: z.ZodString;
                    workerImageDigest: z.ZodString;
                }, z.core.$strict>>;
                harness: z.ZodOptional<z.ZodObject<{
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    agentSnapshot: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    sourcePackageHash: z.ZodString;
                }, z.core.$strict>>;
                messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    role: z.ZodEnum<{
                        assistant: "assistant";
                        system: "system";
                        user: "user";
                    }>;
                    content: z.ZodString;
                }, z.core.$strict>>>;
                maxOutputTokens: z.ZodDefault<z.ZodNumber>;
                temperature: z.ZodDefault<z.ZodNumber>;
                topP: z.ZodDefault<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
                fixtureId: z.ZodString;
            }, z.core.$strict>], "kind">;
        }, z.core.$strict>;
        status: z.ZodEnum<{
            cancelled: "cancelled";
            cancelling: "cancelling";
            completed: "completed";
            failed: "failed";
            queued: "queued";
            running: "running";
        }>;
        policySnapshot: z.ZodNullable<z.ZodObject<{
            modelId: z.ZodString;
            provider: z.ZodString;
            upstreamModelId: z.ZodString;
            configurationHash: z.ZodString;
        }, z.core.$strict>>;
        createdAt: z.ZodISODateTime;
        startedAt: z.ZodNullable<z.ZodISODateTime>;
        completedAt: z.ZodNullable<z.ZodISODateTime>;
        cleanupComplete: z.ZodBoolean;
        resultAvailable: z.ZodBoolean;
        score: z.ZodNullable<z.ZodNumber>;
        gradingStatus: z.ZodDefault<z.ZodEnum<{
            not_configured: "not_configured";
            not_started: "not_started";
            pending: "pending";
            scored: "scored";
            unscorable: "unscorable";
        }>>;
        passed: z.ZodNullable<z.ZodBoolean>;
        outputPreview: z.ZodNullable<z.ZodString>;
        error: z.ZodNullable<z.ZodObject<{
            code: z.ZodString;
            message: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    nextCursor: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare const ModelStarterAttemptResultSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptResult.v1">;
    attempt: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptSummary.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        request: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.modelStarterAttemptRequest.v1">;
            operationId: z.ZodString;
            teamId: z.ZodString;
            modelProjectId: z.ZodNullable<z.ZodString>;
            project: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
                targetId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            taskId: z.ZodString;
            environmentSeed: z.ZodDefault<z.ZodNumber>;
            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"hosted_chat">;
                modelId: z.ZodString;
                localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                    providerId: z.ZodLiteral<"custom-openai-compatible">;
                    configurationHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"claude-code">;
                    configurationHash: z.ZodString;
                    executableHash: z.ZodString;
                    version: z.ZodString;
                    capabilityHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                    maximumTurns: z.ZodNumber;
                    holdOpen: z.ZodBoolean;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"codex">;
                    configurationHash: z.ZodString;
                    accountHash: z.ZodString;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        medium: "medium";
                        xhigh: "xhigh";
                    }>;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>]>>;
                candidate: z.ZodOptional<z.ZodObject<{
                    artifactId: z.ZodString;
                    contentHash: z.ZodString;
                    preparationId: z.ZodString;
                    dispatchId: z.ZodString;
                    baseProfileId: z.ZodString;
                    workerImageDigest: z.ZodString;
                }, z.core.$strict>>;
                harness: z.ZodOptional<z.ZodObject<{
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    agentSnapshot: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    sourcePackageHash: z.ZodString;
                }, z.core.$strict>>;
                messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    role: z.ZodEnum<{
                        assistant: "assistant";
                        system: "system";
                        user: "user";
                    }>;
                    content: z.ZodString;
                }, z.core.$strict>>>;
                maxOutputTokens: z.ZodDefault<z.ZodNumber>;
                temperature: z.ZodDefault<z.ZodNumber>;
                topP: z.ZodDefault<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
                fixtureId: z.ZodString;
            }, z.core.$strict>], "kind">;
        }, z.core.$strict>;
        status: z.ZodEnum<{
            cancelled: "cancelled";
            cancelling: "cancelling";
            completed: "completed";
            failed: "failed";
            queued: "queued";
            running: "running";
        }>;
        policySnapshot: z.ZodNullable<z.ZodObject<{
            modelId: z.ZodString;
            provider: z.ZodString;
            upstreamModelId: z.ZodString;
            configurationHash: z.ZodString;
        }, z.core.$strict>>;
        createdAt: z.ZodISODateTime;
        startedAt: z.ZodNullable<z.ZodISODateTime>;
        completedAt: z.ZodNullable<z.ZodISODateTime>;
        cleanupComplete: z.ZodBoolean;
        resultAvailable: z.ZodBoolean;
        score: z.ZodNullable<z.ZodNumber>;
        gradingStatus: z.ZodDefault<z.ZodEnum<{
            not_configured: "not_configured";
            not_started: "not_started";
            pending: "pending";
            scored: "scored";
            unscorable: "unscorable";
        }>>;
        passed: z.ZodNullable<z.ZodBoolean>;
        outputPreview: z.ZodNullable<z.ZodString>;
        error: z.ZodNullable<z.ZodObject<{
            code: z.ZodString;
            message: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    output: z.ZodNullable<z.ZodString>;
    messages: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    composition: z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
        binding: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        taskHash: z.ZodString;
        taskId: z.ZodOptional<z.ZodString>;
        outputHash: z.ZodString;
        results: z.ZodArray<z.ZodObject<{
            graderId: z.ZodString;
            reward: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            role: z.ZodEnum<{
                evaluation: "evaluation";
                training: "training";
            }>;
            status: z.ZodEnum<{
                failed: "failed";
                not_applicable: "not_applicable";
                pending: "pending";
                scored: "scored";
                unavailable: "unavailable";
            }>;
            rawScore: z.ZodNullable<z.ZodNumber>;
            normalizedScore: z.ZodNullable<z.ZodNumber>;
            passed: z.ZodNullable<z.ZodBoolean>;
            evidenceHashes: z.ZodArray<z.ZodString>;
            graderEvidence: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
                graderId: z.ZodString;
                graderVersion: z.ZodString;
                status: z.ZodOptional<z.ZodEnum<{
                    failed: "failed";
                    pending: "pending";
                    scored: "scored";
                    unavailable: "unavailable";
                }>>;
                score: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodBoolean;
                rewardEligible: z.ZodBoolean;
                failureClass: z.ZodNullable<z.ZodEnum<{
                    cancelled: "cancelled";
                    environment_failure: "environment_failure";
                    grader_failure: "grader_failure";
                    infrastructure_failure: "infrastructure_failure";
                    policy_failure: "policy_failure";
                    timeout: "timeout";
                }>>;
                feedback: z.ZodArray<z.ZodString>;
                visibleEvidenceRefs: z.ZodArray<z.ZodString>;
                privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
                modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
                    providerId: z.ZodString;
                    modelId: z.ZodString;
                    modelRevision: z.ZodNullable<z.ZodString>;
                    responseId: z.ZodNullable<z.ZodString>;
                    requestHash: z.ZodString;
                    responseHash: z.ZodString;
                    inputTokens: z.ZodNullable<z.ZodNumber>;
                    outputTokens: z.ZodNullable<z.ZodNumber>;
                    costUsd: z.ZodNullable<z.ZodNumber>;
                    transportPolicy: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                        responseFormat: z.ZodLiteral<"judgment_json_schema">;
                        reasoningEffort: z.ZodEnum<{
                            high: "high";
                            low: "low";
                            max: "max";
                            medium: "medium";
                            off: "off";
                            xhigh: "xhigh";
                        }>;
                        maximumOutputTokens: z.ZodNumber;
                    }, z.core.$strict>>;
                    effectiveRequestHash: z.ZodOptional<z.ZodString>;
                    finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                    reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                }, z.core.$strict>>;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
            message: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>;
        training: z.ZodObject<{
            status: z.ZodEnum<{
                not_configured: "not_configured";
                pending: "pending";
                scored: "scored";
                unscorable: "unscorable";
            }>;
            score: z.ZodNullable<z.ZodNumber>;
            passed: z.ZodNullable<z.ZodBoolean>;
        }, z.core.$strict>;
        evaluation: z.ZodObject<{
            status: z.ZodEnum<{
                not_configured: "not_configured";
                pending: "pending";
                scored: "scored";
                unscorable: "unscorable";
            }>;
            score: z.ZodNullable<z.ZodNumber>;
            passed: z.ZodNullable<z.ZodBoolean>;
        }, z.core.$strict>;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    grade: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        score: z.ZodNullable<z.ZodNumber>;
        passed: z.ZodBoolean;
        rewardEligible: z.ZodBoolean;
        failureClass: z.ZodNullable<z.ZodEnum<{
            cancelled: "cancelled";
            environment_failure: "environment_failure";
            grader_failure: "grader_failure";
            infrastructure_failure: "infrastructure_failure";
            policy_failure: "policy_failure";
            timeout: "timeout";
        }>>;
        gradingStatus: z.ZodEnum<{
            not_configured: "not_configured";
            pending: "pending";
            scored: "scored";
            unscorable: "unscorable";
        }>;
        schemaVersion: z.ZodLiteral<"openpond.taskGrade.v1">;
        taskHash: z.ZodString;
        evidenceHash: z.ZodString;
        graderSetHash: z.ZodString;
        components: z.ZodArray<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
            graderId: z.ZodString;
            graderVersion: z.ZodString;
            status: z.ZodOptional<z.ZodEnum<{
                failed: "failed";
                pending: "pending";
                scored: "scored";
                unavailable: "unavailable";
            }>>;
            score: z.ZodNullable<z.ZodNumber>;
            passed: z.ZodBoolean;
            rewardEligible: z.ZodBoolean;
            failureClass: z.ZodNullable<z.ZodEnum<{
                cancelled: "cancelled";
                environment_failure: "environment_failure";
                grader_failure: "grader_failure";
                infrastructure_failure: "infrastructure_failure";
                policy_failure: "policy_failure";
                timeout: "timeout";
            }>>;
            feedback: z.ZodArray<z.ZodString>;
            visibleEvidenceRefs: z.ZodArray<z.ZodString>;
            privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
            modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
                providerId: z.ZodString;
                modelId: z.ZodString;
                modelRevision: z.ZodNullable<z.ZodString>;
                responseId: z.ZodNullable<z.ZodString>;
                requestHash: z.ZodString;
                responseHash: z.ZodString;
                inputTokens: z.ZodNullable<z.ZodNumber>;
                outputTokens: z.ZodNullable<z.ZodNumber>;
                costUsd: z.ZodNullable<z.ZodNumber>;
                transportPolicy: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                    responseFormat: z.ZodLiteral<"judgment_json_schema">;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        max: "max";
                        medium: "medium";
                        off: "off";
                        xhigh: "xhigh";
                    }>;
                    maximumOutputTokens: z.ZodNumber;
                }, z.core.$strict>>;
                effectiveRequestHash: z.ZodOptional<z.ZodString>;
                finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            }, z.core.$strict>>;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        contentHash: z.ZodString;
    }, z.core.$strict>>>;
    experimentGrade: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.experimentAttemptGrade.v1">;
        selectionHash: z.ZodString;
        grades: z.ZodArray<z.ZodObject<{
            score: z.ZodNullable<z.ZodNumber>;
            passed: z.ZodBoolean;
            rewardEligible: z.ZodBoolean;
            failureClass: z.ZodNullable<z.ZodEnum<{
                cancelled: "cancelled";
                environment_failure: "environment_failure";
                grader_failure: "grader_failure";
                infrastructure_failure: "infrastructure_failure";
                policy_failure: "policy_failure";
                timeout: "timeout";
            }>>;
            gradingStatus: z.ZodEnum<{
                not_configured: "not_configured";
                pending: "pending";
                scored: "scored";
                unscorable: "unscorable";
            }>;
            schemaVersion: z.ZodLiteral<"openpond.taskGrade.v1">;
            taskHash: z.ZodString;
            evidenceHash: z.ZodString;
            graderSetHash: z.ZodString;
            components: z.ZodArray<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
                graderId: z.ZodString;
                graderVersion: z.ZodString;
                status: z.ZodOptional<z.ZodEnum<{
                    failed: "failed";
                    pending: "pending";
                    scored: "scored";
                    unavailable: "unavailable";
                }>>;
                score: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodBoolean;
                rewardEligible: z.ZodBoolean;
                failureClass: z.ZodNullable<z.ZodEnum<{
                    cancelled: "cancelled";
                    environment_failure: "environment_failure";
                    grader_failure: "grader_failure";
                    infrastructure_failure: "infrastructure_failure";
                    policy_failure: "policy_failure";
                    timeout: "timeout";
                }>>;
                feedback: z.ZodArray<z.ZodString>;
                visibleEvidenceRefs: z.ZodArray<z.ZodString>;
                privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
                modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
                    providerId: z.ZodString;
                    modelId: z.ZodString;
                    modelRevision: z.ZodNullable<z.ZodString>;
                    responseId: z.ZodNullable<z.ZodString>;
                    requestHash: z.ZodString;
                    responseHash: z.ZodString;
                    inputTokens: z.ZodNullable<z.ZodNumber>;
                    outputTokens: z.ZodNullable<z.ZodNumber>;
                    costUsd: z.ZodNullable<z.ZodNumber>;
                    transportPolicy: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                        responseFormat: z.ZodLiteral<"judgment_json_schema">;
                        reasoningEffort: z.ZodEnum<{
                            high: "high";
                            low: "low";
                            max: "max";
                            medium: "medium";
                            off: "off";
                            xhigh: "xhigh";
                        }>;
                        maximumOutputTokens: z.ZodNumber;
                    }, z.core.$strict>>;
                    effectiveRequestHash: z.ZodOptional<z.ZodString>;
                    finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                    reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                }, z.core.$strict>>;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        score: z.ZodNullable<z.ZodNumber>;
        passed: z.ZodBoolean;
        rewardEligible: z.ZodBoolean;
        gradingStatus: z.ZodEnum<{
            not_configured: "not_configured";
            pending: "pending";
            scored: "scored";
            unscorable: "unscorable";
        }>;
        failureClass: z.ZodNullable<z.ZodEnum<{
            cancelled: "cancelled";
            environment_failure: "environment_failure";
            grader_failure: "grader_failure";
            infrastructure_failure: "infrastructure_failure";
            policy_failure: "policy_failure";
            timeout: "timeout";
        }>>;
        contentHash: z.ZodString;
    }, z.core.$strict>>>;
    environment: z.ZodObject<{
        status: z.ZodEnum<{
            budget_exhausted: "budget_exhausted";
            cancelled: "cancelled";
            completed: "completed";
            environment_failure: "environment_failure";
            policy_failure: "policy_failure";
            timed_out: "timed_out";
        }>;
        collected: z.ZodBoolean;
        definition: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        initialStateHash: z.ZodNullable<z.ZodString>;
        finalStateHash: z.ZodNullable<z.ZodString>;
        attemptHash: z.ZodString;
    }, z.core.$strict>;
    native: z.ZodOptional<z.ZodObject<{
        sessionId: z.ZodString;
        turnId: z.ZodString;
        source: z.ZodObject<{
            harnessRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            agentSnapshot: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            sourcePackageHash: z.ZodString;
        }, z.core.$strict>;
        admissionHash: z.ZodString;
        modelConfigurationHash: z.ZodString;
        traceHash: z.ZodString;
        runtimeEventRefs: z.ZodArray<z.ZodString>;
        startedAt: z.ZodString;
        completedAt: z.ZodString;
        outputHash: z.ZodString;
        partialOutputAvailable: z.ZodBoolean;
    }, z.core.$strict>>;
    providerRequestIds: z.ZodArray<z.ZodString>;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type ModelStarterAttemptResult = z.infer<typeof ModelStarterAttemptResultSchema>;
export declare class OpenPondModelStarterAttemptError extends Error {
    readonly status: number;
    readonly code: string;
    constructor(status: number, code: string, message: string);
}
export declare class OpenPondModelStarterAttemptsClient {
    #private;
    constructor(options: {
        baseUrl: string;
        apiKey: string;
        teamId: string;
        fetch?: typeof globalThis.fetch;
    });
    create(value: z.input<typeof ModelStarterAttemptRequestSchema>, options?: {
        signal?: AbortSignal;
    }): Promise<{
        schemaVersion: "openpond.modelStarterAttemptSummary.v1";
        id: string;
        revision: number;
        request: {
            schemaVersion: "openpond.modelStarterAttemptRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskId: string;
            environmentSeed: number;
            policy: {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
                fixtureId: string;
            };
        };
        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        createdAt: string;
        startedAt: string | null;
        completedAt: string | null;
        cleanupComplete: boolean;
        resultAvailable: boolean;
        score: number | null;
        gradingStatus: "not_configured" | "not_started" | "pending" | "scored" | "unscorable";
        passed: boolean | null;
        outputPreview: string | null;
        error: {
            code: string;
            message: string;
        } | null;
    }>;
    get(id: string, options?: {
        signal?: AbortSignal;
    }): Promise<{
        schemaVersion: "openpond.modelStarterAttemptSummary.v1";
        id: string;
        revision: number;
        request: {
            schemaVersion: "openpond.modelStarterAttemptRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskId: string;
            environmentSeed: number;
            policy: {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
                fixtureId: string;
            };
        };
        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        createdAt: string;
        startedAt: string | null;
        completedAt: string | null;
        cleanupComplete: boolean;
        resultAvailable: boolean;
        score: number | null;
        gradingStatus: "not_configured" | "not_started" | "pending" | "scored" | "unscorable";
        passed: boolean | null;
        outputPreview: string | null;
        error: {
            code: string;
            message: string;
        } | null;
    }>;
    choices(value: z.input<typeof ModelStarterAttemptChoicesQuerySchema>, options?: {
        signal?: AbortSignal;
    }): Promise<{
        modelProjectId: string | null;
        taskset: {
            id: string;
            contentHash: string;
            revision: number;
        };
        available: boolean;
        unavailableReason: string | null;
        models: {
            id: string;
            name: string;
            maximumOutputTokens?: number | undefined;
        }[];
        tasks: {
            id: string;
            split: "frozen_eval" | "test" | "train" | "validation";
            inputPreview: string;
            fixtures: {
                id: string;
                label: string;
            }[];
        }[];
        nextCursor: string | null;
    }>;
    cancel(id: string, options?: {
        signal?: AbortSignal;
    }): Promise<{
        schemaVersion: "openpond.modelStarterAttemptSummary.v1";
        id: string;
        revision: number;
        request: {
            schemaVersion: "openpond.modelStarterAttemptRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskId: string;
            environmentSeed: number;
            policy: {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
                fixtureId: string;
            };
        };
        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        createdAt: string;
        startedAt: string | null;
        completedAt: string | null;
        cleanupComplete: boolean;
        resultAvailable: boolean;
        score: number | null;
        gradingStatus: "not_configured" | "not_started" | "pending" | "scored" | "unscorable";
        passed: boolean | null;
        outputPreview: string | null;
        error: {
            code: string;
            message: string;
        } | null;
    }>;
    result(id: string, options?: {
        signal?: AbortSignal;
    }): Promise<{
        schemaVersion: "openpond.modelStarterAttemptResult.v1";
        attempt: {
            schemaVersion: "openpond.modelStarterAttemptSummary.v1";
            id: string;
            revision: number;
            request: {
                schemaVersion: "openpond.modelStarterAttemptRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                taskId: string;
                environmentSeed: number;
                policy: {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                    fixtureId: string;
                };
            };
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            policySnapshot: {
                modelId: string;
                provider: string;
                upstreamModelId: string;
                configurationHash: string;
            } | null;
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            cleanupComplete: boolean;
            resultAvailable: boolean;
            score: number | null;
            gradingStatus: "not_configured" | "not_started" | "pending" | "scored" | "unscorable";
            passed: boolean | null;
            outputPreview: string | null;
            error: {
                code: string;
                message: string;
            } | null;
        };
        output: string | null;
        messages: Record<string, unknown>[];
        composition: {
            schemaVersion: "openpond.rewardComposition.v1";
            binding: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskHash: string;
            taskId?: string | undefined;
            outputHash: string;
            results: {
                graderId: string;
                reward: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                role: "evaluation" | "training";
                status: "failed" | "not_applicable" | "pending" | "scored" | "unavailable";
                rawScore: number | null;
                normalizedScore: number | null;
                passed: boolean | null;
                evidenceHashes: string[];
                graderEvidence?: {
                    schemaVersion: "openpond.graderEvidence.v1";
                    graderId: string;
                    graderVersion: string;
                    status?: "failed" | "pending" | "scored" | "unavailable" | undefined;
                    score: number | null;
                    passed: boolean;
                    rewardEligible: boolean;
                    failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                    feedback: string[];
                    visibleEvidenceRefs: string[];
                    privilegedEvidenceRefs: string[];
                    modelJudgeReceipt?: {
                        schemaVersion: "openpond.modelJudgeReceipt.v1";
                        providerId: string;
                        modelId: string;
                        modelRevision: string | null;
                        responseId: string | null;
                        requestHash: string;
                        responseHash: string;
                        inputTokens: number | null;
                        outputTokens: number | null;
                        costUsd: number | null;
                        transportPolicy?: {
                            schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
                            responseFormat: "judgment_json_schema";
                            reasoningEffort: "high" | "low" | "max" | "medium" | "off" | "xhigh";
                            maximumOutputTokens: number;
                        } | undefined;
                        effectiveRequestHash?: string | undefined;
                        finishReason?: string | null | undefined;
                        reasoningTokens?: number | null | undefined;
                    } | undefined;
                    contentHash: string;
                } | undefined;
                message: string | null;
            }[];
            training: {
                status: "not_configured" | "pending" | "scored" | "unscorable";
                score: number | null;
                passed: boolean | null;
            };
            evaluation: {
                status: "not_configured" | "pending" | "scored" | "unscorable";
                score: number | null;
                passed: boolean | null;
            };
            contentHash: string;
        } | null;
        grade?: {
            score: number | null;
            passed: boolean;
            rewardEligible: boolean;
            failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
            gradingStatus: "not_configured" | "pending" | "scored" | "unscorable";
            schemaVersion: "openpond.taskGrade.v1";
            taskHash: string;
            evidenceHash: string;
            graderSetHash: string;
            components: {
                schemaVersion: "openpond.graderEvidence.v1";
                graderId: string;
                graderVersion: string;
                status?: "failed" | "pending" | "scored" | "unavailable" | undefined;
                score: number | null;
                passed: boolean;
                rewardEligible: boolean;
                failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                feedback: string[];
                visibleEvidenceRefs: string[];
                privilegedEvidenceRefs: string[];
                modelJudgeReceipt?: {
                    schemaVersion: "openpond.modelJudgeReceipt.v1";
                    providerId: string;
                    modelId: string;
                    modelRevision: string | null;
                    responseId: string | null;
                    requestHash: string;
                    responseHash: string;
                    inputTokens: number | null;
                    outputTokens: number | null;
                    costUsd: number | null;
                    transportPolicy?: {
                        schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
                        responseFormat: "judgment_json_schema";
                        reasoningEffort: "high" | "low" | "max" | "medium" | "off" | "xhigh";
                        maximumOutputTokens: number;
                    } | undefined;
                    effectiveRequestHash?: string | undefined;
                    finishReason?: string | null | undefined;
                    reasoningTokens?: number | null | undefined;
                } | undefined;
                contentHash: string;
            }[];
            contentHash: string;
        } | null | undefined;
        experimentGrade?: {
            schemaVersion: "openpond.experimentAttemptGrade.v1";
            selectionHash: string;
            grades: {
                score: number | null;
                passed: boolean;
                rewardEligible: boolean;
                failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                gradingStatus: "not_configured" | "pending" | "scored" | "unscorable";
                schemaVersion: "openpond.taskGrade.v1";
                taskHash: string;
                evidenceHash: string;
                graderSetHash: string;
                components: {
                    schemaVersion: "openpond.graderEvidence.v1";
                    graderId: string;
                    graderVersion: string;
                    status?: "failed" | "pending" | "scored" | "unavailable" | undefined;
                    score: number | null;
                    passed: boolean;
                    rewardEligible: boolean;
                    failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                    feedback: string[];
                    visibleEvidenceRefs: string[];
                    privilegedEvidenceRefs: string[];
                    modelJudgeReceipt?: {
                        schemaVersion: "openpond.modelJudgeReceipt.v1";
                        providerId: string;
                        modelId: string;
                        modelRevision: string | null;
                        responseId: string | null;
                        requestHash: string;
                        responseHash: string;
                        inputTokens: number | null;
                        outputTokens: number | null;
                        costUsd: number | null;
                        transportPolicy?: {
                            schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
                            responseFormat: "judgment_json_schema";
                            reasoningEffort: "high" | "low" | "max" | "medium" | "off" | "xhigh";
                            maximumOutputTokens: number;
                        } | undefined;
                        effectiveRequestHash?: string | undefined;
                        finishReason?: string | null | undefined;
                        reasoningTokens?: number | null | undefined;
                    } | undefined;
                    contentHash: string;
                }[];
                contentHash: string;
            }[];
            score: number | null;
            passed: boolean;
            rewardEligible: boolean;
            gradingStatus: "not_configured" | "pending" | "scored" | "unscorable";
            failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
            contentHash: string;
        } | null | undefined;
        environment: {
            status: "budget_exhausted" | "cancelled" | "completed" | "environment_failure" | "policy_failure" | "timed_out";
            collected: boolean;
            definition: {
                id: string;
                contentHash: string;
                revision: number;
            };
            initialStateHash: string | null;
            finalStateHash: string | null;
            attemptHash: string;
        };
        native?: {
            sessionId: string;
            turnId: string;
            source: {
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                agentSnapshot: {
                    id: string;
                    contentHash: string;
                };
                sourcePackageHash: string;
            };
            admissionHash: string;
            modelConfigurationHash: string;
            traceHash: string;
            runtimeEventRefs: string[];
            startedAt: string;
            completedAt: string;
            outputHash: string;
            partialOutputAvailable: boolean;
        } | undefined;
        providerRequestIds: string[];
        contentHash: string;
    }>;
    list(value: z.input<typeof ModelStarterAttemptListQuerySchema>, options?: {
        signal?: AbortSignal;
    }): Promise<{
        items: {
            schemaVersion: "openpond.modelStarterAttemptSummary.v1";
            id: string;
            revision: number;
            request: {
                schemaVersion: "openpond.modelStarterAttemptRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                taskId: string;
                environmentSeed: number;
                policy: {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                    fixtureId: string;
                };
            };
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            policySnapshot: {
                modelId: string;
                provider: string;
                upstreamModelId: string;
                configurationHash: string;
            } | null;
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            cleanupComplete: boolean;
            resultAvailable: boolean;
            score: number | null;
            gradingStatus: "not_configured" | "not_started" | "pending" | "scored" | "unscorable";
            passed: boolean | null;
            outputPreview: string | null;
            error: {
                code: string;
                message: string;
            } | null;
        }[];
        nextCursor: string | null;
    }>;
}
//# sourceMappingURL=model-starter-attempts.d.ts.map