import type { ContentBlock, ExtensionEvent } from "./contracts.js";
export type MiddlewareHookName = "beforeProviderTurn" | "provider_request" | "input_assembly" | "prompt_build" | "context" | "tool_call" | "tool_result" | "retry" | "compaction_request" | "compaction" | "session_start" | "session_shutdown";
/** Provenance of a host-answered turn (plan 096). An id, never free host code. */
export interface DeterministicTurnProvenance {
    /** Answering middleware id; bounded, replay-stable, and auditable. */
    readonly middleware: string;
}
/** Host middleware answer that completes a turn without any provider request (plan 096). */
export interface DeterministicTurnAnswer {
    /** Assistant content with provider content-block shape; tool calls are rejected (no provider ran). */
    readonly content: readonly ContentBlock[];
    /** Mandatory: a deterministic turn can never masquerade as model output. */
    readonly provenance: DeterministicTurnProvenance;
}
/**
 * Payload for the `beforeProviderTurn` hook (plan 096). Host middleware sets `answer` to complete the
 * turn deterministically; leaving it absent/undefined sends the turn to the provider as usual.
 */
export interface BeforeProviderTurnPayload {
    readonly sessionId: string;
    readonly runId: string;
    readonly turn: number;
    /** Concatenated text blocks of the latest user-role message in the assembled request. */
    readonly userText: string;
    /** Set by host middleware to answer without a provider call. */
    readonly answer?: DeterministicTurnAnswer;
}
/** Host answered with a malformed deterministic turn. Fails the run closed — never falls through. */
export declare class DeterministicTurnError extends Error {
    readonly code = "ERR_PRISM_DETERMINISTIC_TURN";
    constructor(message: string);
}
/**
 * Validate a host deterministic answer at the trust boundary: non-empty assistant-visible content and
 * mandatory bounded provenance. Throws instead of degrading to a provider call.
 */
export declare function validateDeterministicTurnAnswer(value: unknown): DeterministicTurnAnswer;
export type MiddlewareNext<T> = (value: T) => Promise<T>;
export type Middleware<T = unknown> = (value: T, next: MiddlewareNext<T>) => T | Promise<T>;
export interface MiddlewareRegistryOptions {
    readonly errorPolicy?: "event" | "throw";
    readonly secrets?: readonly (string | undefined)[];
    readonly onError?: (event: ExtensionEvent) => void | Promise<void>;
}
export interface MiddlewareRegistry {
    use<T>(hook: MiddlewareHookName | string, middleware: Middleware<T>): () => void;
    run<T>(hook: MiddlewareHookName | string, value: T): Promise<T>;
    list(hook: MiddlewareHookName | string): readonly Middleware[];
}
export declare function createMiddlewareRegistry(options?: MiddlewareRegistryOptions): MiddlewareRegistry;