/**
 * Pi lifecycle hook integration — T021, T021b, SP-055.
 *
 * Registers compaction and model-override hooks on pi extension events.
 * Lifecycle flags are consumed when building the next routing request
 * (extension `buildRoutingRequest` or embedder `dispatch.dispatch`).
 *
 * Routing and stream delegation live in `.pi/extensions/smart-router/` for
 * pi users, or in embedder code that calls `GatewayDispatch.dispatch()`.
 * This module does not register routing or no-op context hooks.
 *
 * Contract: specs/001-build-smart-router/contracts/pi-middleware.md v1.0.0
 */
export interface PiSessionManager {
    getSessionFile(): string | undefined;
    getSessionId(): string;
}
export interface PiExtensionContext {
    readonly cwd: string;
    readonly sessionManager: PiSessionManager;
}
export interface PiMessage {
    readonly role: string;
    readonly content: string;
    readonly tool_call_id?: string;
    readonly tool_calls?: readonly unknown[];
}
export interface PiContextEvent {
    readonly messages: readonly PiMessage[];
}
export interface PiModelSelectEvent {
    readonly source: string;
    readonly model: {
        readonly provider: string;
        readonly id: string;
    };
}
/** Legacy embedder event shape; routing is handled in the pi extension stream path. */
export interface PiProviderRequestEvent {
    readonly provider: string;
    readonly model: string;
    readonly messages?: readonly PiMessage[];
    [key: string]: unknown;
}
export interface PiExtensionHooks {
    on(event: 'before_provider_request', handler: (event: PiProviderRequestEvent, ctx: PiExtensionContext) => PiProviderRequestEvent | Promise<PiProviderRequestEvent>): void;
    on(event: 'context', handler: (event: PiContextEvent, ctx: PiExtensionContext) => void): void;
    on(event: 'session_compact', handler: (event: unknown, ctx: PiExtensionContext) => void): void;
    on(event: 'session_before_compact', handler: (event: unknown, ctx: PiExtensionContext) => void): void;
    on(event: 'model_select', handler: (event: PiModelSelectEvent, ctx: PiExtensionContext) => void): void;
}
export interface LifecycleFlags {
    readonly compaction_flag?: boolean;
    readonly force_model_id?: string;
}
/**
 * Per-session lifecycle flags set by pi compaction and model_select hooks.
 * Shared across router rebuilds so hook state survives fleet refresh.
 */
export declare class LifecycleHookState {
    private readonly sessions;
    private getOrCreate;
    markCompaction(sessionId: string): void;
    setForceModel(sessionId: string, modelId: string): void;
    /**
     * Consume lifecycle flags for the next routing request.
     * Compaction is one-shot; force_model_id is one-shot per consume.
     */
    consume(sessionId: string): LifecycleFlags;
}
export interface PiRouterMiddlewareOptions {
    readonly lifecycleHookState?: LifecycleHookState;
}
export interface PiRouterMiddleware {
    readonly register: (hooks: PiExtensionHooks) => void;
    readonly lifecycleHookState: LifecycleHookState;
}
/**
 * Create pi lifecycle hook handlers for session compaction and model overrides.
 *
 * Library embedders: call `router.register(hooks)` on the returned `RouterHandle`
 * and route via `router.dispatch.dispatch()`. For pi, use the project extension at
 * `.pi/extensions/smart-router/` — it owns stream delegation and routing telemetry.
 */
export declare function createPiRouterMiddleware(options?: PiRouterMiddlewareOptions): PiRouterMiddleware;
//# sourceMappingURL=pi-router-middleware.d.ts.map