import type { EvalSessionEvidenceRequired, EvalSessionExecutionEvidence, OpenedEvalSession } from "@velum-labs/routekit-control";
import { type EvalCandidateTrialPlan, EvalServiceValidationError, type EvalTrialAuthority, type RepositoryAgentModelBinding, type RepositoryAgentModelTrialAuthority, type ServingRequestHttpBinding } from "@velum-labs/routekit-eval-service/effect";
import { type EvalAuthoringCompletion, EvalAuthoringTransport, EvalProjectAuthoringError } from "@velum-labs/routekit-eval-setup";
import { RouteKitFailure } from "@velum-labs/routekit-runtime/effect";
import { Context, Effect, type FileSystem, Layer, type Path, Redacted, type Scope } from "effect";
import type { HttpClient } from "effect/unstable/http";
import { type FoundryExecutionEvidenceIdentity, type FoundryGenerationRejection } from "../protocols/foundry-execution-evidence.js";
import type { RouteKitRemote } from "../remotes.js";
import { type FoundryAuthoringRequestRecorder, FoundryExecutionEvidenceError } from "../stores/foundry-execution-evidence.js";
export type AuthoringSession = {
    readonly sessionId: string;
    readonly gatewayUrl: string;
    readonly bearerCredential: Redacted.Redacted<string>;
    readonly evidenceRequired?: true;
    readonly upstreamRetrySafe?: () => Effect.Effect<boolean, Error, HttpClient.HttpClient>;
};
export declare const evalSessionGatewayUrl: (openedGatewayUrl: string, _selectedRemote?: Pick<RouteKitRemote, "sshHost">) => string;
export declare const evalAuthoringResponseStatusFailureDetail: (payload: unknown, callId?: string | null, maximumOutputTokens?: number) => string | undefined;
export declare const evalAuthoringStructuredOutput: (input: {
    readonly operation: EvalProjectAuthoringError["operation"];
    readonly text: string;
    readonly callId?: string | null;
    readonly schemaName: string;
    readonly jsonSchema: Readonly<Record<string, unknown>>;
}) => Effect.Effect<string, EvalProjectAuthoringError>;
export declare const evalAuthoringRequestBody: (input: EvalAuthoringCompletion) => string;
export declare const evalAuthoringResponsePayload: (response: Response, operation: EvalProjectAuthoringError["operation"], onActivity?: () => void, onReturned?: () => Effect.Effect<void, EvalProjectAuthoringError>) => Effect.Effect<unknown, EvalProjectAuthoringError>;
export declare const evalAuthoringResponseFailureDetail: (response: Response) => Effect.Effect<string>;
export declare function withEvalAuthoringWallTime<A, E, R>(effect: Effect.Effect<A, E, R>, input: {
    readonly wallTimeMs: number;
    readonly expiresAt: string;
    readonly nowMs?: number;
}): Effect.Effect<A, E | RouteKitFailure, R>;
export declare function makeTargetAuthoringTransport(session: AuthoringSession, httpContext: Context.Context<HttpClient.HttpClient>, transientRetryBudget: number, reviewInputVersion?: 2, requestRecorder?: FoundryAuthoringRequestRecorder): import("@velum-labs/routekit-eval-setup").EvalAuthoringTransportShape;
type TargetAuthoringSessionInput<A, E, R> = {
    readonly operationId: string;
    readonly model: string;
    readonly allowedModels?: readonly string[];
    readonly calls: number;
    readonly maximumOutputTokens: number;
    readonly totalInputTokens?: number;
    readonly totalOutputTokens?: number;
    readonly wallTimeMs?: number;
    readonly transientRetryBudget?: number;
    readonly reviewInputVersion?: 2;
    readonly requestRecorder?: FoundryAuthoringRequestRecorder;
    readonly evidenceRequired?: EvalSessionEvidenceRequired;
    /** Internal scoped readiness continuation, before any generation work. */
    readonly onReady?: (opened: OpenedEvalSession) => Effect.Effect<FoundryAuthoringRequestRecorder, E, R>;
    readonly onUpstreamEvidence?: (opened: OpenedEvalSession, evidence: EvalSessionExecutionEvidence) => Effect.Effect<void, Error, R>;
    /** Ephemeral control invocation identity; never substitutes for the plan digest. */
    readonly sessionIdempotencyKey?: string;
    readonly use: (layer: Layer.Layer<EvalAuthoringTransport>) => Effect.Effect<A, E, R>;
};
export type FoundryCandidateTrialTarget = {
    readonly lane: "repository-agent";
    readonly binding: RepositoryAgentModelBinding;
    readonly authority: RepositoryAgentModelTrialAuthority;
    readonly bearerCredential: Redacted.Redacted<string>;
} | {
    readonly lane: "request";
    readonly binding: ServingRequestHttpBinding;
    readonly authority: EvalTrialAuthority<ServingRequestHttpBinding, EvalServiceValidationError>;
    readonly bearerCredential: Redacted.Redacted<string>;
};
/**
 * Accept only the direct host failure, or that sole Fail reason in the complete
 * Effect Cause. Wrappers, other reasons, defects and interruptions are not
 * semantic authority, even when their text or nested error contains a marker.
 */
export declare function foundryGenerationRejectionFromCause(cause: unknown): FoundryGenerationRejection | undefined;
/**
 * The existing session owner supplies the complete scoped operation, including
 * cleanup. Observer events and an inner `use` return cannot close this evidence.
 */
export declare function withFoundryExecutionEvidence<A, E, R>(input: {
    readonly identity: FoundryExecutionEvidenceIdentity;
    readonly maximumPhysicalRequests: number;
    readonly use: (recorder: FoundryAuthoringRequestRecorder) => Effect.Effect<A, E, R>;
}): Effect.Effect<A, FoundryExecutionEvidenceError | E, FileSystem.FileSystem | Path.Path | R>;
export declare function withFoundryAuthoringSession<A, E, R>(input: Omit<TargetAuthoringSessionInput<A, E, R>, "requestRecorder" | "onReady" | "sessionIdempotencyKey" | "evidenceRequired" | "onUpstreamEvidence"> & {
    readonly executionIdentity: FoundryExecutionEvidenceIdentity;
    /** The supervisor commits its own consumed ledger after this owner is ready. */
    readonly beforeExecution?: Effect.Effect<void, unknown>;
}): Effect.Effect<A, unknown, HttpClient.HttpClient | FileSystem.FileSystem | Path.Path | R>;
/**
 * The actual candidate continuation of the existing target owner. It reloads
 * canonical host sources itself; no caller-provided target identity, evidence
 * reader, receipt, hidden answer, alternate session or stand-alone ledger can
 * authorize a candidate request.
 *
 * The return value is an exposure-closed candidate execution only. Existing
 * hidden/output/trajectory harnesses, admission and routing qualify it
 * separately; neither an adapter summary nor an inner checkpoint is a grade.
 */
export declare function withFoundryCandidateTrialSession<A, E, R>(input: {
    readonly repositoryRoot: string;
    readonly benchmarkArtifactPath: string;
    readonly manifestPath: string;
    readonly plan: EvalCandidateTrialPlan;
    readonly use: (target: FoundryCandidateTrialTarget) => Effect.Effect<A, E, R | Scope.Scope>;
}): Effect.Effect<A, E | Error, R | FileSystem.FileSystem | Path.Path | HttpClient.HttpClient>;
export declare function withTargetAuthoringSession<A, E, R>(input: TargetAuthoringSessionInput<A, E, R>): Effect.Effect<A, E | Error, R | HttpClient.HttpClient>;
export {};