@kortyx/agent 0.27.0 → 0.29.0

package/dist/studio-judge-BFF0TsT2.d.ts

@@ -0,0 +1,2279 @@
+import { GetProviderFn, ProviderModelRef } from '@kortyx/providers';
+import { z } from 'zod';
+import { KortyxError, FailureDescriptor } from '@kortyx/core/errors';
+import { FinalizedChatMessage, StreamChunk } from '@kortyx/stream';
+import { WorkflowDefinition, ExecutionLimits, TokenUsage, ExecutionLimitReached } from '@kortyx/core';
+import { PendingRequestRecord, PendingRequestStore, CheckpointSummary, CheckpointId, SessionCheckpointRecord, RollbackSessionCheckpointResult, ForkSessionCheckpointResult, WorkflowRegistry, FrameworkAdapter, ExecutionRuntimeConfig } from '@kortyx/runtime';
+import { KortyxTelemetryConfig, EnsureWorkflowTopologyRequest } from '@kortyx/hooks';
+import { C as ChatMessage } from './chat-message-D4EsFcr1.js';
+
+type ChatResponseStatus = "completed" | "failed" | "cancelled" | "interrupted";
+type ChatResponseFinalized = {
+    sessionId: string;
+    runId: string;
+    clientTurnId: string;
+    status: ChatResponseStatus;
+    message: FinalizedChatMessage;
+    checkpointId?: string;
+};
+type ChatLifecyclePhase = "turn-accepted" | "response-finalized" | "forked" | "rolled-back";
+declare class ChatLifecycleHookError extends KortyxError {
+    readonly phase: ChatLifecyclePhase;
+    constructor(phase: ChatLifecyclePhase, cause: unknown);
+}
+
+type ExecutableWorkflow = WorkflowDefinition & {
+    inputSchema: z.ZodType;
+    outputSchema: z.ZodType<Record<string, unknown>>;
+};
+/** Serializable identity of a waiting request. Treat tokens as private credentials. */
+type ResumeHandle = {
+    token: string;
+    requestId: string;
+    sessionId: string;
+    runId: string;
+};
+type ResumeResponse = {
+    type: "text";
+    text: string;
+} | {
+    type: "select";
+    ids: string[];
+} | {
+    type: "value";
+    value: unknown;
+} | {
+    type: "cancel";
+};
+type ExecutionInterrupt = {
+    workflow: string;
+    node: string;
+    input: PendingRequestRecord["schema"] & {
+        options: Array<{
+            id: string;
+            label: string;
+            description?: string | undefined;
+        }>;
+    };
+};
+type ExecutionInfo = {
+    runId: string;
+    sessionId: string;
+    checkpointId?: string;
+    usage?: TokenUsage;
+};
+type ExecutionResult<T = Record<string, unknown>> = ExecutionInfo & ({
+    status: "completed";
+    data: T;
+} | {
+    status: "suspended";
+    reason?: "limit_reached";
+    limit?: ExecutionLimitReached;
+    interrupt: ExecutionInterrupt;
+    resume: ResumeHandle;
+} | {
+    status: "cancelled";
+    reason: string;
+} | {
+    status: "failed";
+    error: Pick<FailureDescriptor, "code" | "message"> & Partial<FailureDescriptor>;
+});
+type ExecuteOptions<W extends ExecutableWorkflow> = {
+    limits?: ExecutionLimits;
+    abortSignal?: AbortSignal;
+    workflow: W;
+    input: z.input<W["inputSchema"]>;
+    sessionId?: string;
+    context?: Record<string, unknown>;
+};
+type ResumeOptions<W extends ExecutableWorkflow> = {
+    limits?: ExecutionLimits;
+    abortSignal?: AbortSignal;
+    workflow: W;
+    resume: ResumeHandle;
+    response: ResumeResponse;
+};
+/** The command was rejected before starting work or claiming an interrupt. */
+declare class ExecutionRequestError extends KortyxError {
+    name: string;
+    constructor(code: string, message: string, cause?: unknown);
+}
+
+declare const scopeSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strict>;
+type InterruptScope = z.input<typeof scopeSchema>;
+type ListInterruptsOptions = InterruptScope & {
+    status?: "pending";
+    afterResponseCompleted?: boolean;
+};
+type PendingInterrupt = {
+    id: string;
+    status: "pending";
+    runId: string;
+    sessionId: string;
+    workflow: string;
+    node: string;
+    createdAt: string;
+    expiresAt: string;
+    afterResponseCompleted: boolean;
+    input: Omit<PendingRequestRecord["schema"], "meta"> & {
+        options: Array<{
+            id: string;
+            label: string;
+            description?: string;
+        }>;
+    };
+};
+type ResumableInterrupt = PendingInterrupt & {
+    resume: ResumeHandle;
+};
+declare function createInterruptDiscovery(store: PendingRequestStore): {
+    listInterrupts(options: ListInterruptsOptions): Promise<PendingInterrupt[]>;
+    getInterrupt(id: string, scope: InterruptScope): Promise<ResumableInterrupt | null>;
+};
+
+/** Produces the topology-only, deterministic Contract A snapshot. */
+declare const projectWorkflowTopology: (args: {
+    workflow: WorkflowDefinition;
+    environment: string;
+    service: NonNullable<KortyxTelemetryConfig["service"]>;
+    knownWorkflowIds?: readonly string[] | undefined;
+}) => EnsureWorkflowTopologyRequest;
+
+interface AgentProcessOptions {
+    executionSignal?: AbortSignal | undefined;
+    onExecution?: ((completion: Promise<void>) => void) | undefined;
+    clientTurnId?: string | undefined;
+    continueOnDisconnect?: boolean | undefined;
+    onResponseFinalized?: ((event: ChatResponseFinalized) => void | Promise<void>) | undefined;
+    limits?: ExecutionLimits | undefined;
+    abortSignal?: AbortSignal | undefined;
+    sessionId?: string | undefined;
+    workflowId?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}
+type AgentTopologySnapshot = ReturnType<typeof projectWorkflowTopology>;
+interface AgentProjectTopologyOptions {
+    environment: string;
+    service: AgentTopologySnapshot["service"];
+}
+interface CreateAgentArgs {
+    limits?: ExecutionLimits | undefined;
+    getProvider?: GetProviderFn | undefined;
+    workflows?: WorkflowDefinition[];
+    workflowsDir?: string;
+    workflowRegistry?: WorkflowRegistry;
+    defaultWorkflowId?: string;
+    frameworkAdapter?: FrameworkAdapter;
+    telemetry?: ExecutionRuntimeConfig["telemetry"];
+}
+interface Agent extends ReturnType<typeof createInterruptDiscovery> {
+    execute<W extends ExecutableWorkflow>(args: ExecuteOptions<W>): Promise<ExecutionResult<z.output<W["outputSchema"]>>>;
+    execute(args: {
+        limits?: ExecutionLimits;
+        abortSignal?: AbortSignal;
+        workflow: string;
+        input: unknown;
+        sessionId?: string;
+        context?: Record<string, unknown>;
+    }): Promise<ExecutionResult>;
+    resume<W extends ExecutableWorkflow>(args: ResumeOptions<W>): Promise<ExecutionResult<z.output<W["outputSchema"]>>>;
+    resume(args: {
+        limits?: ExecutionLimits;
+        abortSignal?: AbortSignal;
+        workflow: string;
+        resume: ResumeHandle;
+        response: ResumeResponse;
+    }): Promise<ExecutionResult>;
+    projectTopology?: (options: AgentProjectTopologyOptions) => Promise<AgentTopologySnapshot[]>;
+    streamChat: (messages: ChatMessage[], options?: AgentProcessOptions) => Promise<AsyncIterable<StreamChunk>>;
+    listCheckpoints: (sessionId: string) => Promise<CheckpointSummary[]>;
+    getCheckpoint: (id: CheckpointId) => Promise<SessionCheckpointRecord | null>;
+    rollbackTo: (id: CheckpointId) => Promise<RollbackSessionCheckpointResult>;
+    fork: (id: CheckpointId, options?: {
+        newSessionId?: string;
+    }) => Promise<ForkSessionCheckpointResult>;
+}
+declare function createAgent(args: CreateAgentArgs): Agent;
+
+type EvalJson = null | boolean | number | string | readonly EvalJson[] | {
+    readonly [key: string]: EvalJson;
+};
+type EvalHandlerRef = {
+    using: string;
+    params?: EvalJson;
+};
+type EvalCriterion = string | {
+    id: string;
+    text: string;
+};
+type EvalOutputExpectation = {
+    schemaId: string;
+    schemaVersion?: string;
+};
+type EvalExpectation = {
+    type: "answer" | "interrupt";
+    schemaId?: string;
+    schemaVersion?: string;
+    /** Required completed structured output contracts in this step; other outputs are allowed. */
+    outputs?: readonly EvalOutputExpectation[];
+    criteria?: readonly EvalCriterion[];
+    reference?: EvalJson;
+};
+type EvalStep = ({
+    message: string;
+    resume?: never;
+} | {
+    resume: ResumeResponse | EvalHandlerRef;
+    message?: never;
+}) & {
+    expect: EvalExpectation;
+};
+type EvalCase<Params = EvalJson> = {
+    id: string;
+    name?: string;
+    params?: Params;
+    workflowId?: string;
+    steps: readonly EvalStep[];
+};
+type EvalSuite<Params = EvalJson> = {
+    id: string;
+    name?: string;
+    cases: readonly EvalCase<Params>[];
+};
+type EvalInterrupt = {
+    requestId: string;
+    kind: "text" | "choice" | "multi-choice" | "custom";
+    question?: string;
+    schemaId?: string;
+    schemaVersion?: string;
+    options: readonly {
+        id: string;
+        label: string;
+        description?: string;
+    }[];
+    request?: EvalJson;
+};
+/** Public output and emitted execution evidence; private runtime state is excluded. */
+type EvalObservation = {
+    type: "answer" | "interrupt" | "error" | "cancelled";
+    text: string;
+    structured: readonly EvalJson[];
+    /** Ordered public stream events. Adjacent text deltas from the same source are joined. */
+    events?: readonly EvalJson[];
+    interrupt?: EvalInterrupt;
+    runId?: string;
+    checkpointId?: string;
+};
+type EvalCommand = {
+    type: "message";
+    message: string;
+} | {
+    type: "resume";
+    response: ResumeResponse;
+} | {
+    type: "cancel";
+};
+/** continuation is process-private and is never copied to results or progress events. */
+type EvalExecution = {
+    observation: EvalObservation;
+    continuation?: unknown;
+};
+type EvalStatus = "passed" | "failed" | "error" | "cancelled";
+/** Execution can finish before Studio has evaluated its semantic criteria. */
+type EvalExecutionStatus = EvalStatus | "ungraded";
+type EvalJudgeIdentity = {
+    id: string;
+    version: string;
+    location?: "app" | "studio" | undefined;
+};
+type EvalPhase = "params" | "setup" | "execute" | "responder" | "reference" | "grading" | "cleanup" | "reporting";
+type EvalIssue = {
+    phase: EvalPhase;
+    code: string;
+    message: string;
+};
+type EvalVerdict = {
+    passed: boolean;
+    reason: string;
+    evidence: readonly string[];
+};
+type EvalCriterionResult = EvalVerdict & {
+    id: string;
+    text: string;
+};
+type EvalJudgeUsage = z.infer<typeof EvalJudgeUsageSchema>;
+type EvalStepResult = {
+    judgeCalls?: number;
+    judgeUsage?: EvalJudgeUsage[];
+    index: number;
+    input: {
+        message: string;
+    } | {
+        resume: ResumeResponse;
+    };
+    expectation: EvalExpectation;
+    observation: EvalObservation;
+    reference?: EvalJson;
+    status: EvalExecutionStatus;
+    reason?: string;
+    criteria: EvalCriterionResult[];
+};
+type EvalCaseResult = {
+    caseId: string;
+    repetition: number;
+    sessionId: string;
+    status: EvalExecutionStatus;
+    durationMs: number;
+    steps: EvalStepResult[];
+    errors: EvalIssue[];
+};
+type EvalRunResult = {
+    id: string;
+    suiteId: string;
+    suiteRevision: string;
+    suite: EvalSuite;
+    judge?: EvalJudgeIdentity;
+    startedAt: string;
+    durationMs: number;
+    status: EvalExecutionStatus;
+    counts: Record<EvalStatus, number> & {
+        ungraded?: number;
+    };
+    cases: EvalCaseResult[];
+    errors: EvalIssue[];
+};
+type EvalGradeInput = {
+    /** Trusted provider billing evidence, independent of the generated verdict. */
+    onUsage?: (usage: EvalJudgeUsage) => void;
+    criterion: {
+        id: string;
+        text: string;
+    };
+    input: EvalStepResult["input"];
+    observation: EvalObservation;
+    reference?: EvalJson;
+    conversation: readonly EvalStepResult[];
+    signal: AbortSignal;
+};
+type EvalJudge = {
+    id: string;
+    version: string;
+    location?: "app" | "studio";
+    grade: (input: EvalGradeInput) => Promise<EvalVerdict> | EvalVerdict;
+};
+type EvalJudgeOptions = {
+    model: ProviderModelRef;
+    id?: string;
+    version?: string;
+};
+type StudioEvalJudgeOptions = {
+    /** Studio API origin, not the browser Studio URL. */
+    url: string;
+    apiKey: string;
+    environment: string;
+    allowInsecureHttp?: boolean;
+    /** Optional deadline for initial judge discovery. */
+    signal?: AbortSignal;
+};
+type EvalSetupContext<Params> = {
+    suiteId: string;
+    case: EvalCase;
+    repetition: number;
+    sessionId: string;
+    params: Params;
+    signal: AbortSignal;
+};
+type EvalContext<Params, Prepared> = EvalSetupContext<Params> & {
+    prepared: Prepared;
+};
+type EvalResponder<Params, Prepared> = ((input: EvalContext<Params, Prepared> & {
+    interrupt: EvalInterrupt;
+    args?: EvalJson;
+}) => ResumeResponse | Promise<ResumeResponse>) | {
+    schemaId: string;
+    schemaVersion?: string;
+    respond: (input: EvalContext<Params, Prepared> & {
+        interrupt: EvalInterrupt;
+        args?: EvalJson;
+    }) => ResumeResponse | Promise<ResumeResponse>;
+};
+type EvalDefaults = {
+    repetitions?: number;
+    concurrency?: number;
+    caseTimeoutMs?: number;
+    cleanupTimeoutMs?: number;
+};
+type CreateEvalsOptions<Params = EvalJson | undefined, Prepared = undefined> = {
+    agent: Pick<Agent, "streamChat">;
+    suites: readonly EvalSuite[];
+    paramsSchema?: z.ZodType<Params>;
+    setup?: (input: EvalSetupContext<Params>) => Prepared | Promise<Prepared>;
+    execute?: (input: EvalContext<Params, NoInfer<Prepared>> & {
+        command: EvalCommand;
+        continuation?: unknown;
+        history: readonly ChatMessage[];
+        run: (options?: {
+            context?: Record<string, unknown>;
+            messages?: ChatMessage[];
+        }) => Promise<EvalExecution>;
+    }) => EvalExecution | Promise<EvalExecution>;
+    teardown?: (input: EvalContext<Params, NoInfer<Prepared>> & {
+        result: EvalCaseResult;
+    }) => void | Promise<void>;
+    responders?: Record<string, EvalResponder<Params, NoInfer<Prepared>>>;
+    references?: Record<string, (input: EvalContext<Params, NoInfer<Prepared>> & {
+        observation: EvalObservation;
+        args?: EvalJson;
+    }) => EvalJson | Promise<EvalJson>>;
+    judge?: EvalJudge;
+    defaults?: EvalDefaults;
+};
+type EvalProgress = {
+    type: "run-started";
+    caseIds: string[];
+    repetitions: number;
+    concurrency: number;
+} | {
+    type: "case-progress";
+    caseId: string;
+    repetition: number;
+    phase: EvalPhase;
+    stepIndex?: number;
+} | {
+    type: "case-started";
+    caseId: string;
+    repetition: number;
+    sessionId: string;
+} | {
+    type: "step-completed";
+    caseId: string;
+    repetition: number;
+    step: EvalStepResult;
+} | {
+    type: "case-completed";
+    result: EvalCaseResult;
+};
+type EvalRunOptions = {
+    /** Studio captures execution without invoking the code judge. Local runs default to app. */
+    grading?: "app" | "studio";
+    /** Selected identity pinned by the Studio server when enqueuing a run. */
+    judgeIdentity?: EvalJudgeIdentity;
+    suiteId: string;
+    caseIds?: readonly string[];
+    repetitions?: number;
+    concurrency?: number;
+    signal?: AbortSignal;
+    onProgress?: (event: EvalProgress) => void | Promise<void>;
+    /** Include live run totals and case phases; off for legacy progress consumers. */
+    includeActivity?: boolean;
+};
+
+declare const EvalResumeResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"value">;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+}, z.core.$strict>], "type">;
+declare const EvalSuiteSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    cases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodJSONSchema>;
+        workflowId: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            message: z.ZodString;
+            expect: z.ZodObject<{
+                type: z.ZodEnum<{
+                    interrupt: "interrupt";
+                    answer: "answer";
+                }>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>]>>>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            resume: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"select">;
+                ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"value">;
+                value: z.ZodJSONSchema;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"cancel">;
+            }, z.core.$strict>], "type">, z.ZodObject<{
+                using: z.ZodString;
+                params: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>]>;
+            expect: z.ZodObject<{
+                type: z.ZodEnum<{
+                    interrupt: "interrupt";
+                    answer: "answer";
+                }>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>]>>>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvalVerdictSchema: z.ZodObject<{
+    passed: z.ZodBoolean;
+    reason: z.ZodString;
+    evidence: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const EvalObservationSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        cancelled: "cancelled";
+        interrupt: "interrupt";
+        error: "error";
+        answer: "answer";
+    }>;
+    text: z.ZodString;
+    structured: z.ZodArray<z.ZodJSONSchema>;
+    events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+    runId: z.ZodOptional<z.ZodString>;
+    checkpointId: z.ZodOptional<z.ZodString>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodEnum<{
+            text: "text";
+            custom: "custom";
+            "multi-choice": "multi-choice";
+            choice: "choice";
+        }>;
+        question: z.ZodOptional<z.ZodString>;
+        schemaId: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodOptional<z.ZodString>;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        request: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Billing evidence only: no prompts, provider raw responses, or credentials. */
+declare const EvalJudgeUsageSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    occurredAt: z.ZodISODateTime;
+    usage: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+        reasoning: z.ZodOptional<z.ZodNumber>;
+        cacheRead: z.ZodOptional<z.ZodNumber>;
+        cacheWrite: z.ZodOptional<z.ZodNumber>;
+        cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+        outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+        inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+        inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    pricingContext: z.ZodOptional<z.ZodObject<{
+        serviceTier: z.ZodOptional<z.ZodString>;
+        inferenceGeo: z.ZodOptional<z.ZodString>;
+        speed: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        source: z.ZodLiteral<"provider">;
+        currency: z.ZodLiteral<"USD">;
+        actualCostMicros: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvalStepResultSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    input: z.ZodUnion<readonly [z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"select">;
+            ids: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"value">;
+            value: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"cancel">;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>]>;
+    expectation: z.ZodObject<{
+        type: z.ZodEnum<{
+            interrupt: "interrupt";
+            answer: "answer";
+        }>;
+        schemaId: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodOptional<z.ZodString>;
+        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schemaId: z.ZodString;
+            schemaVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>]>>>;
+        reference: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>;
+    observation: z.ZodObject<{
+        type: z.ZodEnum<{
+            cancelled: "cancelled";
+            interrupt: "interrupt";
+            error: "error";
+            answer: "answer";
+        }>;
+        text: z.ZodString;
+        structured: z.ZodArray<z.ZodJSONSchema>;
+        events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+        runId: z.ZodOptional<z.ZodString>;
+        checkpointId: z.ZodOptional<z.ZodString>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            requestId: z.ZodString;
+            kind: z.ZodEnum<{
+                text: "text";
+                custom: "custom";
+                "multi-choice": "multi-choice";
+                choice: "choice";
+            }>;
+            question: z.ZodOptional<z.ZodString>;
+            schemaId: z.ZodOptional<z.ZodString>;
+            schemaVersion: z.ZodOptional<z.ZodString>;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            request: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    reference: z.ZodOptional<z.ZodJSONSchema>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        error: "error";
+        passed: "passed";
+        ungraded: "ungraded";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    judgeCalls: z.ZodOptional<z.ZodNumber>;
+    judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        occurredAt: z.ZodISODateTime;
+        usage: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+            cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+            outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+            inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+            inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        pricingContext: z.ZodOptional<z.ZodObject<{
+            serviceTier: z.ZodOptional<z.ZodString>;
+            inferenceGeo: z.ZodOptional<z.ZodString>;
+            speed: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        pricing: z.ZodOptional<z.ZodObject<{
+            source: z.ZodLiteral<"provider">;
+            currency: z.ZodLiteral<"USD">;
+            actualCostMicros: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    criteria: z.ZodArray<z.ZodObject<{
+        passed: z.ZodBoolean;
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvalCaseResultSchema: z.ZodObject<{
+    caseId: z.ZodString;
+    repetition: z.ZodNumber;
+    sessionId: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        error: "error";
+        passed: "passed";
+        ungraded: "ungraded";
+    }>;
+    durationMs: z.ZodNumber;
+    steps: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        input: z.ZodUnion<readonly [z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"select">;
+                ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"value">;
+                value: z.ZodJSONSchema;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"cancel">;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>]>;
+        expectation: z.ZodObject<{
+            type: z.ZodEnum<{
+                interrupt: "interrupt";
+                answer: "answer";
+            }>;
+            schemaId: z.ZodOptional<z.ZodString>;
+            schemaVersion: z.ZodOptional<z.ZodString>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schemaId: z.ZodString;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>]>>>;
+            reference: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strict>;
+        observation: z.ZodObject<{
+            type: z.ZodEnum<{
+                cancelled: "cancelled";
+                interrupt: "interrupt";
+                error: "error";
+                answer: "answer";
+            }>;
+            text: z.ZodString;
+            structured: z.ZodArray<z.ZodJSONSchema>;
+            events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+            runId: z.ZodOptional<z.ZodString>;
+            checkpointId: z.ZodOptional<z.ZodString>;
+            interrupt: z.ZodOptional<z.ZodObject<{
+                requestId: z.ZodString;
+                kind: z.ZodEnum<{
+                    text: "text";
+                    custom: "custom";
+                    "multi-choice": "multi-choice";
+                    choice: "choice";
+                }>;
+                question: z.ZodOptional<z.ZodString>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                request: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        reference: z.ZodOptional<z.ZodJSONSchema>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            error: "error";
+            passed: "passed";
+            ungraded: "ungraded";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        judgeCalls: z.ZodOptional<z.ZodNumber>;
+        judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            usage: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodNumber>;
+                output: z.ZodOptional<z.ZodNumber>;
+                total: z.ZodOptional<z.ZodNumber>;
+                reasoning: z.ZodOptional<z.ZodNumber>;
+                cacheRead: z.ZodOptional<z.ZodNumber>;
+                cacheWrite: z.ZodOptional<z.ZodNumber>;
+                cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            pricingContext: z.ZodOptional<z.ZodObject<{
+                serviceTier: z.ZodOptional<z.ZodString>;
+                inferenceGeo: z.ZodOptional<z.ZodString>;
+                speed: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pricing: z.ZodOptional<z.ZodObject<{
+                source: z.ZodLiteral<"provider">;
+                currency: z.ZodLiteral<"USD">;
+                actualCostMicros: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        criteria: z.ZodArray<z.ZodObject<{
+            passed: z.ZodBoolean;
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodString>;
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    errors: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            params: "params";
+            execute: "execute";
+            setup: "setup";
+            responder: "responder";
+            reference: "reference";
+            grading: "grading";
+            cleanup: "cleanup";
+            reporting: "reporting";
+        }>;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvalJudgeIdentitySchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    location: z.ZodOptional<z.ZodEnum<{
+        app: "app";
+        studio: "studio";
+    }>>;
+}, z.core.$strict>;
+declare const StudioEvalJudgeRequestSchema: z.ZodObject<{
+    environment: z.ZodString;
+    judge: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        location: z.ZodOptional<z.ZodEnum<{
+            app: "app";
+            studio: "studio";
+        }>>;
+    }, z.core.$strict>;
+    criterion: z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>;
+    input: z.ZodUnion<readonly [z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"select">;
+            ids: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"value">;
+            value: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"cancel">;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>]>;
+    observation: z.ZodObject<{
+        type: z.ZodEnum<{
+            cancelled: "cancelled";
+            interrupt: "interrupt";
+            error: "error";
+            answer: "answer";
+        }>;
+        text: z.ZodString;
+        structured: z.ZodArray<z.ZodJSONSchema>;
+        events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+        runId: z.ZodOptional<z.ZodString>;
+        checkpointId: z.ZodOptional<z.ZodString>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            requestId: z.ZodString;
+            kind: z.ZodEnum<{
+                text: "text";
+                custom: "custom";
+                "multi-choice": "multi-choice";
+                choice: "choice";
+            }>;
+            question: z.ZodOptional<z.ZodString>;
+            schemaId: z.ZodOptional<z.ZodString>;
+            schemaVersion: z.ZodOptional<z.ZodString>;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            request: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    reference: z.ZodOptional<z.ZodJSONSchema>;
+    conversation: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        input: z.ZodUnion<readonly [z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"select">;
+                ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"value">;
+                value: z.ZodJSONSchema;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"cancel">;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>]>;
+        expectation: z.ZodObject<{
+            type: z.ZodEnum<{
+                interrupt: "interrupt";
+                answer: "answer";
+            }>;
+            schemaId: z.ZodOptional<z.ZodString>;
+            schemaVersion: z.ZodOptional<z.ZodString>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schemaId: z.ZodString;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>]>>>;
+            reference: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strict>;
+        observation: z.ZodObject<{
+            type: z.ZodEnum<{
+                cancelled: "cancelled";
+                interrupt: "interrupt";
+                error: "error";
+                answer: "answer";
+            }>;
+            text: z.ZodString;
+            structured: z.ZodArray<z.ZodJSONSchema>;
+            events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+            runId: z.ZodOptional<z.ZodString>;
+            checkpointId: z.ZodOptional<z.ZodString>;
+            interrupt: z.ZodOptional<z.ZodObject<{
+                requestId: z.ZodString;
+                kind: z.ZodEnum<{
+                    text: "text";
+                    custom: "custom";
+                    "multi-choice": "multi-choice";
+                    choice: "choice";
+                }>;
+                question: z.ZodOptional<z.ZodString>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                request: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        reference: z.ZodOptional<z.ZodJSONSchema>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            error: "error";
+            passed: "passed";
+            ungraded: "ungraded";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        judgeCalls: z.ZodOptional<z.ZodNumber>;
+        judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            usage: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodNumber>;
+                output: z.ZodOptional<z.ZodNumber>;
+                total: z.ZodOptional<z.ZodNumber>;
+                reasoning: z.ZodOptional<z.ZodNumber>;
+                cacheRead: z.ZodOptional<z.ZodNumber>;
+                cacheWrite: z.ZodOptional<z.ZodNumber>;
+                cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            pricingContext: z.ZodOptional<z.ZodObject<{
+                serviceTier: z.ZodOptional<z.ZodString>;
+                inferenceGeo: z.ZodOptional<z.ZodString>;
+                speed: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pricing: z.ZodOptional<z.ZodObject<{
+                source: z.ZodLiteral<"provider">;
+                currency: z.ZodLiteral<"USD">;
+                actualCostMicros: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        criteria: z.ZodArray<z.ZodObject<{
+            passed: z.ZodBoolean;
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodString>;
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const StudioEvalJudgeResponseSchema: z.ZodObject<{
+    judge: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        location: z.ZodOptional<z.ZodEnum<{
+            app: "app";
+            studio: "studio";
+        }>>;
+    }, z.core.$strict>;
+    verdict: z.ZodObject<{
+        passed: z.ZodBoolean;
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    usage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        occurredAt: z.ZodISODateTime;
+        usage: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+            reasoning: z.ZodOptional<z.ZodNumber>;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+            cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+            outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+            inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+            inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        pricingContext: z.ZodOptional<z.ZodObject<{
+            serviceTier: z.ZodOptional<z.ZodString>;
+            inferenceGeo: z.ZodOptional<z.ZodString>;
+            speed: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        pricing: z.ZodOptional<z.ZodObject<{
+            source: z.ZodLiteral<"provider">;
+            currency: z.ZodLiteral<"USD">;
+            actualCostMicros: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const EvalRunResultSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    suiteId: z.ZodString;
+    suiteRevision: z.ZodString;
+    suite: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        cases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodJSONSchema>;
+            workflowId: z.ZodOptional<z.ZodString>;
+            steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                message: z.ZodString;
+                expect: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        interrupt: "interrupt";
+                        answer: "answer";
+                    }>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        id: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    reference: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                resume: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"select">;
+                    ids: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"cancel">;
+                }, z.core.$strict>], "type">, z.ZodObject<{
+                    using: z.ZodString;
+                    params: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>]>;
+                expect: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        interrupt: "interrupt";
+                        answer: "answer";
+                    }>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        id: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    reference: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    judge: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        location: z.ZodOptional<z.ZodEnum<{
+            app: "app";
+            studio: "studio";
+        }>>;
+    }, z.core.$strict>>;
+    startedAt: z.ZodISODateTime;
+    durationMs: z.ZodNumber;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        error: "error";
+        passed: "passed";
+        ungraded: "ungraded";
+    }>;
+    counts: z.ZodObject<{
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        error: z.ZodNumber;
+        cancelled: z.ZodNumber;
+        ungraded: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    cases: z.ZodArray<z.ZodObject<{
+        caseId: z.ZodString;
+        repetition: z.ZodNumber;
+        sessionId: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            error: "error";
+            passed: "passed";
+            ungraded: "ungraded";
+        }>;
+        durationMs: z.ZodNumber;
+        steps: z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            input: z.ZodUnion<readonly [z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"select">;
+                    ids: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"cancel">;
+                }, z.core.$strict>], "type">;
+            }, z.core.$strict>]>;
+            expectation: z.ZodObject<{
+                type: z.ZodEnum<{
+                    interrupt: "interrupt";
+                    answer: "answer";
+                }>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>]>>>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>;
+            observation: z.ZodObject<{
+                type: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    interrupt: "interrupt";
+                    error: "error";
+                    answer: "answer";
+                }>;
+                text: z.ZodString;
+                structured: z.ZodArray<z.ZodJSONSchema>;
+                events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                runId: z.ZodOptional<z.ZodString>;
+                checkpointId: z.ZodOptional<z.ZodString>;
+                interrupt: z.ZodOptional<z.ZodObject<{
+                    requestId: z.ZodString;
+                    kind: z.ZodEnum<{
+                        text: "text";
+                        custom: "custom";
+                        "multi-choice": "multi-choice";
+                        choice: "choice";
+                    }>;
+                    question: z.ZodOptional<z.ZodString>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    options: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    request: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            reference: z.ZodOptional<z.ZodJSONSchema>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                error: "error";
+                passed: "passed";
+                ungraded: "ungraded";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            judgeCalls: z.ZodOptional<z.ZodNumber>;
+            judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+                occurredAt: z.ZodISODateTime;
+                usage: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodOptional<z.ZodNumber>;
+                    output: z.ZodOptional<z.ZodNumber>;
+                    total: z.ZodOptional<z.ZodNumber>;
+                    reasoning: z.ZodOptional<z.ZodNumber>;
+                    cacheRead: z.ZodOptional<z.ZodNumber>;
+                    cacheWrite: z.ZodOptional<z.ZodNumber>;
+                    cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                    outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                    inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                    inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                pricingContext: z.ZodOptional<z.ZodObject<{
+                    serviceTier: z.ZodOptional<z.ZodString>;
+                    inferenceGeo: z.ZodOptional<z.ZodString>;
+                    speed: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                pricing: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodLiteral<"provider">;
+                    currency: z.ZodLiteral<"USD">;
+                    actualCostMicros: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            criteria: z.ZodArray<z.ZodObject<{
+                passed: z.ZodBoolean;
+                reason: z.ZodString;
+                evidence: z.ZodArray<z.ZodString>;
+                id: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        errors: z.ZodArray<z.ZodObject<{
+            phase: z.ZodEnum<{
+                params: "params";
+                execute: "execute";
+                setup: "setup";
+                responder: "responder";
+                reference: "reference";
+                grading: "grading";
+                cleanup: "cleanup";
+                reporting: "reporting";
+            }>;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    errors: z.ZodArray<z.ZodObject<{
+        phase: z.ZodEnum<{
+            params: "params";
+            execute: "execute";
+            setup: "setup";
+            responder: "responder";
+            reference: "reference";
+            grading: "grading";
+            cleanup: "cleanup";
+            reporting: "reporting";
+        }>;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvalManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    studioJudging: z.ZodOptional<z.ZodLiteral<true>>;
+    suites: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        cases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodJSONSchema>;
+            workflowId: z.ZodOptional<z.ZodString>;
+            steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                message: z.ZodString;
+                expect: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        interrupt: "interrupt";
+                        answer: "answer";
+                    }>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        id: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    reference: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                resume: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"select">;
+                    ids: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"cancel">;
+                }, z.core.$strict>], "type">, z.ZodObject<{
+                    using: z.ZodString;
+                    params: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>]>;
+                expect: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        interrupt: "interrupt";
+                        answer: "answer";
+                    }>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        id: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    reference: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    responders: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        schemaId: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    references: z.ZodArray<z.ZodString>;
+    paramsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    judge: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        location: z.ZodOptional<z.ZodEnum<{
+            app: "app";
+            studio: "studio";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const EvalProgressSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"run-started">;
+    caseIds: z.ZodArray<z.ZodString>;
+    repetitions: z.ZodNumber;
+    concurrency: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"case-progress">;
+    caseId: z.ZodString;
+    repetition: z.ZodNumber;
+    phase: z.ZodEnum<{
+        params: "params";
+        execute: "execute";
+        setup: "setup";
+        responder: "responder";
+        reference: "reference";
+        grading: "grading";
+        cleanup: "cleanup";
+        reporting: "reporting";
+    }>;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"case-started">;
+    caseId: z.ZodString;
+    repetition: z.ZodNumber;
+    sessionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"step-completed">;
+    caseId: z.ZodString;
+    repetition: z.ZodNumber;
+    step: z.ZodObject<{
+        index: z.ZodNumber;
+        input: z.ZodUnion<readonly [z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"select">;
+                ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"value">;
+                value: z.ZodJSONSchema;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"cancel">;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>]>;
+        expectation: z.ZodObject<{
+            type: z.ZodEnum<{
+                interrupt: "interrupt";
+                answer: "answer";
+            }>;
+            schemaId: z.ZodOptional<z.ZodString>;
+            schemaVersion: z.ZodOptional<z.ZodString>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schemaId: z.ZodString;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                id: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>]>>>;
+            reference: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strict>;
+        observation: z.ZodObject<{
+            type: z.ZodEnum<{
+                cancelled: "cancelled";
+                interrupt: "interrupt";
+                error: "error";
+                answer: "answer";
+            }>;
+            text: z.ZodString;
+            structured: z.ZodArray<z.ZodJSONSchema>;
+            events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+            runId: z.ZodOptional<z.ZodString>;
+            checkpointId: z.ZodOptional<z.ZodString>;
+            interrupt: z.ZodOptional<z.ZodObject<{
+                requestId: z.ZodString;
+                kind: z.ZodEnum<{
+                    text: "text";
+                    custom: "custom";
+                    "multi-choice": "multi-choice";
+                    choice: "choice";
+                }>;
+                question: z.ZodOptional<z.ZodString>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                request: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        reference: z.ZodOptional<z.ZodJSONSchema>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            error: "error";
+            passed: "passed";
+            ungraded: "ungraded";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        judgeCalls: z.ZodOptional<z.ZodNumber>;
+        judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            usage: z.ZodOptional<z.ZodObject<{
+                input: z.ZodOptional<z.ZodNumber>;
+                output: z.ZodOptional<z.ZodNumber>;
+                total: z.ZodOptional<z.ZodNumber>;
+                reasoning: z.ZodOptional<z.ZodNumber>;
+                cacheRead: z.ZodOptional<z.ZodNumber>;
+                cacheWrite: z.ZodOptional<z.ZodNumber>;
+                cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            pricingContext: z.ZodOptional<z.ZodObject<{
+                serviceTier: z.ZodOptional<z.ZodString>;
+                inferenceGeo: z.ZodOptional<z.ZodString>;
+                speed: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pricing: z.ZodOptional<z.ZodObject<{
+                source: z.ZodLiteral<"provider">;
+                currency: z.ZodLiteral<"USD">;
+                actualCostMicros: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        criteria: z.ZodArray<z.ZodObject<{
+            passed: z.ZodBoolean;
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodString>;
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"case-completed">;
+    result: z.ZodObject<{
+        caseId: z.ZodString;
+        repetition: z.ZodNumber;
+        sessionId: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            error: "error";
+            passed: "passed";
+            ungraded: "ungraded";
+        }>;
+        durationMs: z.ZodNumber;
+        steps: z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            input: z.ZodUnion<readonly [z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"select">;
+                    ids: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"cancel">;
+                }, z.core.$strict>], "type">;
+            }, z.core.$strict>]>;
+            expectation: z.ZodObject<{
+                type: z.ZodEnum<{
+                    interrupt: "interrupt";
+                    answer: "answer";
+                }>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>]>>>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>;
+            observation: z.ZodObject<{
+                type: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    interrupt: "interrupt";
+                    error: "error";
+                    answer: "answer";
+                }>;
+                text: z.ZodString;
+                structured: z.ZodArray<z.ZodJSONSchema>;
+                events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                runId: z.ZodOptional<z.ZodString>;
+                checkpointId: z.ZodOptional<z.ZodString>;
+                interrupt: z.ZodOptional<z.ZodObject<{
+                    requestId: z.ZodString;
+                    kind: z.ZodEnum<{
+                        text: "text";
+                        custom: "custom";
+                        "multi-choice": "multi-choice";
+                        choice: "choice";
+                    }>;
+                    question: z.ZodOptional<z.ZodString>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    options: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    request: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            reference: z.ZodOptional<z.ZodJSONSchema>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                error: "error";
+                passed: "passed";
+                ungraded: "ungraded";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            judgeCalls: z.ZodOptional<z.ZodNumber>;
+            judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+                occurredAt: z.ZodISODateTime;
+                usage: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodOptional<z.ZodNumber>;
+                    output: z.ZodOptional<z.ZodNumber>;
+                    total: z.ZodOptional<z.ZodNumber>;
+                    reasoning: z.ZodOptional<z.ZodNumber>;
+                    cacheRead: z.ZodOptional<z.ZodNumber>;
+                    cacheWrite: z.ZodOptional<z.ZodNumber>;
+                    cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                    outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                    inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                    inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                pricingContext: z.ZodOptional<z.ZodObject<{
+                    serviceTier: z.ZodOptional<z.ZodString>;
+                    inferenceGeo: z.ZodOptional<z.ZodString>;
+                    speed: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                pricing: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodLiteral<"provider">;
+                    currency: z.ZodLiteral<"USD">;
+                    actualCostMicros: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            criteria: z.ZodArray<z.ZodObject<{
+                passed: z.ZodBoolean;
+                reason: z.ZodString;
+                evidence: z.ZodArray<z.ZodString>;
+                id: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        errors: z.ZodArray<z.ZodObject<{
+            phase: z.ZodEnum<{
+                params: "params";
+                execute: "execute";
+                setup: "setup";
+                responder: "responder";
+                reference: "reference";
+                grading: "grading";
+                cleanup: "cleanup";
+                reporting: "reporting";
+            }>;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+declare const EvalRemoteRunRequestSchema: z.ZodObject<{
+    suiteId: z.ZodString;
+    suiteRevision: z.ZodString;
+    grading: z.ZodOptional<z.ZodEnum<{
+        app: "app";
+        studio: "studio";
+    }>>;
+    judge: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        location: z.ZodOptional<z.ZodEnum<{
+            app: "app";
+            studio: "studio";
+        }>>;
+    }, z.core.$strict>>;
+    caseIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    repetitions: z.ZodDefault<z.ZodNumber>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+declare const StudioEvalStartRequestSchema: z.ZodObject<{
+    suiteId: z.ZodString;
+    suiteRevision: z.ZodString;
+    caseIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    repetitions: z.ZodDefault<z.ZodNumber>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    targetId: z.ZodString;
+    judge: z.ZodDefault<z.ZodEnum<{
+        app: "app";
+        studio: "studio";
+    }>>;
+}, z.core.$strict>;
+declare const EvalWireEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"progress">;
+    event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"run-started">;
+        caseIds: z.ZodArray<z.ZodString>;
+        repetitions: z.ZodNumber;
+        concurrency: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"case-progress">;
+        caseId: z.ZodString;
+        repetition: z.ZodNumber;
+        phase: z.ZodEnum<{
+            params: "params";
+            execute: "execute";
+            setup: "setup";
+            responder: "responder";
+            reference: "reference";
+            grading: "grading";
+            cleanup: "cleanup";
+            reporting: "reporting";
+        }>;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"case-started">;
+        caseId: z.ZodString;
+        repetition: z.ZodNumber;
+        sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"step-completed">;
+        caseId: z.ZodString;
+        repetition: z.ZodNumber;
+        step: z.ZodObject<{
+            index: z.ZodNumber;
+            input: z.ZodUnion<readonly [z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"select">;
+                    ids: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"cancel">;
+                }, z.core.$strict>], "type">;
+            }, z.core.$strict>]>;
+            expectation: z.ZodObject<{
+                type: z.ZodEnum<{
+                    interrupt: "interrupt";
+                    answer: "answer";
+                }>;
+                schemaId: z.ZodOptional<z.ZodString>;
+                schemaVersion: z.ZodOptional<z.ZodString>;
+                outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schemaId: z.ZodString;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>]>>>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strict>;
+            observation: z.ZodObject<{
+                type: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    interrupt: "interrupt";
+                    error: "error";
+                    answer: "answer";
+                }>;
+                text: z.ZodString;
+                structured: z.ZodArray<z.ZodJSONSchema>;
+                events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                runId: z.ZodOptional<z.ZodString>;
+                checkpointId: z.ZodOptional<z.ZodString>;
+                interrupt: z.ZodOptional<z.ZodObject<{
+                    requestId: z.ZodString;
+                    kind: z.ZodEnum<{
+                        text: "text";
+                        custom: "custom";
+                        "multi-choice": "multi-choice";
+                        choice: "choice";
+                    }>;
+                    question: z.ZodOptional<z.ZodString>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    options: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    request: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            reference: z.ZodOptional<z.ZodJSONSchema>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                error: "error";
+                passed: "passed";
+                ungraded: "ungraded";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            judgeCalls: z.ZodOptional<z.ZodNumber>;
+            judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+                occurredAt: z.ZodISODateTime;
+                usage: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodOptional<z.ZodNumber>;
+                    output: z.ZodOptional<z.ZodNumber>;
+                    total: z.ZodOptional<z.ZodNumber>;
+                    reasoning: z.ZodOptional<z.ZodNumber>;
+                    cacheRead: z.ZodOptional<z.ZodNumber>;
+                    cacheWrite: z.ZodOptional<z.ZodNumber>;
+                    cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                    outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                    inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                    inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                pricingContext: z.ZodOptional<z.ZodObject<{
+                    serviceTier: z.ZodOptional<z.ZodString>;
+                    inferenceGeo: z.ZodOptional<z.ZodString>;
+                    speed: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                pricing: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodLiteral<"provider">;
+                    currency: z.ZodLiteral<"USD">;
+                    actualCostMicros: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            criteria: z.ZodArray<z.ZodObject<{
+                passed: z.ZodBoolean;
+                reason: z.ZodString;
+                evidence: z.ZodArray<z.ZodString>;
+                id: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"case-completed">;
+        result: z.ZodObject<{
+            caseId: z.ZodString;
+            repetition: z.ZodNumber;
+            sessionId: z.ZodString;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                error: "error";
+                passed: "passed";
+                ungraded: "ungraded";
+            }>;
+            durationMs: z.ZodNumber;
+            steps: z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                input: z.ZodUnion<readonly [z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"select">;
+                        ids: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"value">;
+                        value: z.ZodJSONSchema;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"cancel">;
+                    }, z.core.$strict>], "type">;
+                }, z.core.$strict>]>;
+                expectation: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        interrupt: "interrupt";
+                        answer: "answer";
+                    }>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        id: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    reference: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+                observation: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        cancelled: "cancelled";
+                        interrupt: "interrupt";
+                        error: "error";
+                        answer: "answer";
+                    }>;
+                    text: z.ZodString;
+                    structured: z.ZodArray<z.ZodJSONSchema>;
+                    events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                    runId: z.ZodOptional<z.ZodString>;
+                    checkpointId: z.ZodOptional<z.ZodString>;
+                    interrupt: z.ZodOptional<z.ZodObject<{
+                        requestId: z.ZodString;
+                        kind: z.ZodEnum<{
+                            text: "text";
+                            custom: "custom";
+                            "multi-choice": "multi-choice";
+                            choice: "choice";
+                        }>;
+                        question: z.ZodOptional<z.ZodString>;
+                        schemaId: z.ZodOptional<z.ZodString>;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                        options: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            label: z.ZodString;
+                            description: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>;
+                        request: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    failed: "failed";
+                    error: "error";
+                    passed: "passed";
+                    ungraded: "ungraded";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                judgeCalls: z.ZodOptional<z.ZodNumber>;
+                judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    provider: z.ZodString;
+                    model: z.ZodString;
+                    occurredAt: z.ZodISODateTime;
+                    usage: z.ZodOptional<z.ZodObject<{
+                        input: z.ZodOptional<z.ZodNumber>;
+                        output: z.ZodOptional<z.ZodNumber>;
+                        total: z.ZodOptional<z.ZodNumber>;
+                        reasoning: z.ZodOptional<z.ZodNumber>;
+                        cacheRead: z.ZodOptional<z.ZodNumber>;
+                        cacheWrite: z.ZodOptional<z.ZodNumber>;
+                        cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                        outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                        inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                        inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                    pricingContext: z.ZodOptional<z.ZodObject<{
+                        serviceTier: z.ZodOptional<z.ZodString>;
+                        inferenceGeo: z.ZodOptional<z.ZodString>;
+                        speed: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    pricing: z.ZodOptional<z.ZodObject<{
+                        source: z.ZodLiteral<"provider">;
+                        currency: z.ZodLiteral<"USD">;
+                        actualCostMicros: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodArray<z.ZodObject<{
+                    passed: z.ZodBoolean;
+                    reason: z.ZodString;
+                    evidence: z.ZodArray<z.ZodString>;
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            errors: z.ZodArray<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    params: "params";
+                    execute: "execute";
+                    setup: "setup";
+                    responder: "responder";
+                    reference: "reference";
+                    grading: "grading";
+                    cleanup: "cleanup";
+                    reporting: "reporting";
+                }>;
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    result: z.ZodObject<{
+        id: z.ZodUUID;
+        suiteId: z.ZodString;
+        suiteRevision: z.ZodString;
+        suite: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            cases: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                params: z.ZodOptional<z.ZodJSONSchema>;
+                workflowId: z.ZodOptional<z.ZodString>;
+                steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    message: z.ZodString;
+                    expect: z.ZodObject<{
+                        type: z.ZodEnum<{
+                            interrupt: "interrupt";
+                            answer: "answer";
+                        }>;
+                        schemaId: z.ZodOptional<z.ZodString>;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            schemaId: z.ZodString;
+                            schemaVersion: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>;
+                        criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            id: z.ZodString;
+                            text: z.ZodString;
+                        }, z.core.$strict>]>>>;
+                        reference: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    resume: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"select">;
+                        ids: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"value">;
+                        value: z.ZodJSONSchema;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"cancel">;
+                    }, z.core.$strict>], "type">, z.ZodObject<{
+                        using: z.ZodString;
+                        params: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strict>]>;
+                    expect: z.ZodObject<{
+                        type: z.ZodEnum<{
+                            interrupt: "interrupt";
+                            answer: "answer";
+                        }>;
+                        schemaId: z.ZodOptional<z.ZodString>;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                        outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            schemaId: z.ZodString;
+                            schemaVersion: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>;
+                        criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            id: z.ZodString;
+                            text: z.ZodString;
+                        }, z.core.$strict>]>>>;
+                        reference: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        judge: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            location: z.ZodOptional<z.ZodEnum<{
+                app: "app";
+                studio: "studio";
+            }>>;
+        }, z.core.$strict>>;
+        startedAt: z.ZodISODateTime;
+        durationMs: z.ZodNumber;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            error: "error";
+            passed: "passed";
+            ungraded: "ungraded";
+        }>;
+        counts: z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            error: z.ZodNumber;
+            cancelled: z.ZodNumber;
+            ungraded: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        cases: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            repetition: z.ZodNumber;
+            sessionId: z.ZodString;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                error: "error";
+                passed: "passed";
+                ungraded: "ungraded";
+            }>;
+            durationMs: z.ZodNumber;
+            steps: z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                input: z.ZodUnion<readonly [z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    resume: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"select">;
+                        ids: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"value">;
+                        value: z.ZodJSONSchema;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"cancel">;
+                    }, z.core.$strict>], "type">;
+                }, z.core.$strict>]>;
+                expectation: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        interrupt: "interrupt";
+                        answer: "answer";
+                    }>;
+                    schemaId: z.ZodOptional<z.ZodString>;
+                    schemaVersion: z.ZodOptional<z.ZodString>;
+                    outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        schemaId: z.ZodString;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    criteria: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        id: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>]>>>;
+                    reference: z.ZodOptional<z.ZodJSONSchema>;
+                }, z.core.$strict>;
+                observation: z.ZodObject<{
+                    type: z.ZodEnum<{
+                        cancelled: "cancelled";
+                        interrupt: "interrupt";
+                        error: "error";
+                        answer: "answer";
+                    }>;
+                    text: z.ZodString;
+                    structured: z.ZodArray<z.ZodJSONSchema>;
+                    events: z.ZodOptional<z.ZodArray<z.ZodJSONSchema>>;
+                    runId: z.ZodOptional<z.ZodString>;
+                    checkpointId: z.ZodOptional<z.ZodString>;
+                    interrupt: z.ZodOptional<z.ZodObject<{
+                        requestId: z.ZodString;
+                        kind: z.ZodEnum<{
+                            text: "text";
+                            custom: "custom";
+                            "multi-choice": "multi-choice";
+                            choice: "choice";
+                        }>;
+                        question: z.ZodOptional<z.ZodString>;
+                        schemaId: z.ZodOptional<z.ZodString>;
+                        schemaVersion: z.ZodOptional<z.ZodString>;
+                        options: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            label: z.ZodString;
+                            description: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>;
+                        request: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                reference: z.ZodOptional<z.ZodJSONSchema>;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    failed: "failed";
+                    error: "error";
+                    passed: "passed";
+                    ungraded: "ungraded";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                judgeCalls: z.ZodOptional<z.ZodNumber>;
+                judgeUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    provider: z.ZodString;
+                    model: z.ZodString;
+                    occurredAt: z.ZodISODateTime;
+                    usage: z.ZodOptional<z.ZodObject<{
+                        input: z.ZodOptional<z.ZodNumber>;
+                        output: z.ZodOptional<z.ZodNumber>;
+                        total: z.ZodOptional<z.ZodNumber>;
+                        reasoning: z.ZodOptional<z.ZodNumber>;
+                        cacheRead: z.ZodOptional<z.ZodNumber>;
+                        cacheWrite: z.ZodOptional<z.ZodNumber>;
+                        cacheWrite1h: z.ZodOptional<z.ZodNumber>;
+                        outputIncludesReasoning: z.ZodOptional<z.ZodBoolean>;
+                        inputIncludesCacheRead: z.ZodOptional<z.ZodBoolean>;
+                        inputIncludesCacheWrite: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                    pricingContext: z.ZodOptional<z.ZodObject<{
+                        serviceTier: z.ZodOptional<z.ZodString>;
+                        inferenceGeo: z.ZodOptional<z.ZodString>;
+                        speed: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    pricing: z.ZodOptional<z.ZodObject<{
+                        source: z.ZodLiteral<"provider">;
+                        currency: z.ZodLiteral<"USD">;
+                        actualCostMicros: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                criteria: z.ZodArray<z.ZodObject<{
+                    passed: z.ZodBoolean;
+                    reason: z.ZodString;
+                    evidence: z.ZodArray<z.ZodString>;
+                    id: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            errors: z.ZodArray<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    params: "params";
+                    execute: "execute";
+                    setup: "setup";
+                    responder: "responder";
+                    reference: "reference";
+                    grading: "grading";
+                    cleanup: "cleanup";
+                    reporting: "reporting";
+                }>;
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        errors: z.ZodArray<z.ZodObject<{
+            phase: z.ZodEnum<{
+                params: "params";
+                execute: "execute";
+                setup: "setup";
+                responder: "responder";
+                reference: "reference";
+                grading: "grading";
+                cleanup: "cleanup";
+                reporting: "reporting";
+            }>;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strict>], "type">;
+type EvalManifest = z.infer<typeof EvalManifestSchema>;
+type EvalRemoteRunRequest = z.infer<typeof EvalRemoteRunRequestSchema>;
+type EvalWireEvent = z.infer<typeof EvalWireEventSchema>;
+declare class EvalConfigurationError extends Error {
+    name: string;
+}
+declare function parseEvalSuite(value: unknown): EvalSuite;
+
+type DefinedSuite<Params> = Omit<EvalSuite<Params>, "cases"> & {
+    cases: readonly (Omit<EvalCase<Params>, "params"> & (undefined extends Params ? {
+        params?: Exclude<Params, undefined>;
+    } : {
+        params: Params;
+    }))[];
+};
+/** Author a suite with typed case parameters. Runtime validation belongs to createEvals. */
+declare function defineSuite<Params = EvalJson | undefined>(suite: DefinedSuite<Params>): DefinedSuite<Params>;
+
+/** Discover and pin the Studio backend's judge; grading never runs in the browser. */
+declare function createStudioEvalJudge(options: StudioEvalJudgeOptions): Promise<EvalJudge>;
+
+export { StudioEvalStartRequestSchema as $, type EvalOutputExpectation as A, type EvalPhase as B, type CreateEvalsOptions as C, type EvalProgress as D, type EvalCase as E, EvalProgressSchema as F, type EvalRemoteRunRequest as G, EvalRemoteRunRequestSchema as H, type EvalResponder as I, EvalResumeResponseSchema as J, type EvalRunOptions as K, type EvalRunResult as L, EvalRunResultSchema as M, type EvalSetupContext as N, type EvalStatus as O, type EvalStep as P, type EvalStepResult as Q, EvalStepResultSchema as R, type EvalSuite as S, EvalSuiteSchema as T, type EvalVerdict as U, EvalVerdictSchema as V, type EvalWireEvent as W, EvalWireEventSchema as X, type StudioEvalJudgeOptions as Y, StudioEvalJudgeRequestSchema as Z, StudioEvalJudgeResponseSchema as _, type EvalCaseResult as a, createStudioEvalJudge as a0, defineSuite as a1, parseEvalSuite as a2, type ChatLifecyclePhase as a3, ChatLifecycleHookError as a4, type Agent as a5, type ChatResponseFinalized as a6, type AgentProcessOptions as a7, type AgentProjectTopologyOptions as a8, type ChatResponseStatus as a9, type CreateAgentArgs as aa, type ExecutableWorkflow as ab, type ExecuteOptions as ac, type ExecutionInfo as ad, type ExecutionInterrupt as ae, ExecutionRequestError as af, type ExecutionResult as ag, type InterruptScope as ah, type ListInterruptsOptions as ai, type PendingInterrupt as aj, type ResumableInterrupt as ak, type ResumeHandle as al, type ResumeOptions as am, type ResumeResponse as an, createAgent as ao, projectWorkflowTopology as ap, EvalCaseResultSchema as b, type EvalCommand as c, EvalConfigurationError as d, type EvalContext as e, type EvalCriterion as f, type EvalCriterionResult as g, type EvalDefaults as h, type EvalExecution as i, type EvalExecutionStatus as j, type EvalExpectation as k, type EvalGradeInput as l, type EvalHandlerRef as m, type EvalInterrupt as n, type EvalIssue as o, type EvalJson as p, type EvalJudge as q, type EvalJudgeIdentity as r, EvalJudgeIdentitySchema as s, type EvalJudgeOptions as t, type EvalJudgeUsage as u, EvalJudgeUsageSchema as v, type EvalManifest as w, EvalManifestSchema as x, type EvalObservation as y, EvalObservationSchema as z };