import type { DelegateInvocation } from "../../plan/types.js";
import type { DispatchFinding } from "../types.js";
export type FabricModelRequest = Pick<DelegateInvocation, "model" | "fallbackModels">;
/** The canonical key returned by Fabric's agents.models({ runner: "pi" }). */
export interface FabricAvailableModel {
    readonly key: string;
}
/** Named fields ready for the Fabric dispatch receipt; absent means inherited. */
export interface FabricModelSelection {
    readonly status: "resolved";
    readonly requestedModel?: string;
    readonly resolvedModel?: string;
    readonly chosenModel?: string;
}
export interface FabricModelRejected {
    readonly status: "rejected";
    readonly dispatchState: "not-dispatched";
    readonly finding: Extract<DispatchFinding, {
        code: "delegate-runtime-error";
    }> & {
        readonly runtimeCode: "model-unavailable";
    };
}
export type FabricModelResolution = FabricModelSelection | FabricModelRejected;
/**
 * Select exact catalog keys, never Fabric's fuzzy nearest-model substitution.
 * This preserves the explicit fallback order and prevents a misspelled request
 * from silently choosing a different model ahead of an available fallback.
 */
export declare function resolveFabricDispatchModel(request: FabricModelRequest, available: readonly FabricAvailableModel[]): FabricModelResolution;
export interface FabricModelDispatchDependencies<T> {
    models(options: {
        readonly runner: "pi";
    }): Promise<readonly FabricAvailableModel[]>;
    run(model: string | undefined, selection: FabricModelSelection): Promise<T>;
}
export type FabricModelDispatchResult<T> = FabricModelRejected | {
    readonly status: "dispatched";
    readonly selection: FabricModelSelection;
    readonly result: T;
};
/** Resolve before submission; availability failures and run failures never retry. */
export declare function dispatchWithFabricModel<T>(request: FabricModelRequest, dependencies: FabricModelDispatchDependencies<T>): Promise<FabricModelDispatchResult<T>>;