import { type Api, type AssistantMessage, type AssistantMessageEventStream, type AuthResult, type Context, type DeferredHandle, type Model, type ModelsApiStreamOptions, type ModelsDeferredCancelOptions, type ModelsDeferredFetchOptions, type ModelsRequestTransforms, type ModelsSimpleStreamOptions, type MutableModels, type ProviderHeaders, type SimpleStreamOptions, type StreamOptions } from "@bastani/pi-ai";
import type { ModelRuntimeAuthOverrides } from "./model-runtime-types.ts";
export declare function mergeHeaders(base: ProviderHeaders | undefined, override: ProviderHeaders | undefined): ProviderHeaders | undefined;
/** SDK-owned request-auth result so transport preparation does not start a second deadline. */
export interface PreparedRequestAuth {
    readonly resolution: AuthResult | undefined;
    readonly reprepare?: () => Promise<{
        model: Model<Api>;
        options: ModelRuntimeSimpleStreamOptions;
    }>;
    readonly streamSimple?: (model: Model<Api>, context: Context, options: SimpleStreamOptions) => AssistantMessageEventStream;
}
export type ModelRuntimePreparedStreamOptions = StreamOptions & ModelsRequestTransforms & {
    preparedRequestAuth?: PreparedRequestAuth;
};
export type ModelRuntimeSimpleStreamOptions = ModelsSimpleStreamOptions & {
    preparedRequestAuth?: PreparedRequestAuth;
};
type ResolveAuth = (model: Model<Api>, overrides?: ModelRuntimeAuthOverrides) => Promise<AuthResult | undefined>;
/** Whether an extension owns this model's transport, in which case it owns its serialization too. */
type OwnsExtensionTransport = (model: Model<Api>) => boolean;
/** Streaming request preparation split from ModelRuntime solely for Atomic's 500-line source gate. */
export declare class ModelRuntimeStreaming {
    private readonly models;
    private readonly resolveAuth;
    private readonly ownsExtensionTransport;
    private readonly transportModel;
    private readonly reloadCredentials;
    constructor(models: MutableModels, resolveAuth: ResolveAuth, ownsExtensionTransport: OwnsExtensionTransport, transportModel?: (model: Model<Api>) => Model<Api>, reloadCredentials?: () => Promise<void>);
    /**
     * Attach the first-party ChatGPT Codex routing identity to a prepared request.
     *
     * This must happen *after* `prepareRequest`, not before it. The wrapper works by mutating the
     * header object it captures at construction, and `prepareRequest` rebuilds headers through
     * `mergeHeaders`, which copies — so a wrapper applied upstream is silently inert. The wrapper
     * decides from the final payload whether the request is priority, so a normal model still ends up
     * with `originator: pi` and no routing hint.
     */
    private withCodexRouting;
    private prepareRequest;
    stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): AssistantMessageEventStream;
    complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): Promise<AssistantMessage>;
    streamSimple(model: Model<Api>, context: Context, options?: ModelRuntimeSimpleStreamOptions): AssistantMessageEventStream;
    completeSimple(model: Model<Api>, context: Context, options?: ModelRuntimeSimpleStreamOptions): Promise<AssistantMessage>;
    private streamWithCredentialRetry;
    fetchDeferred(model: Model<Api>, handle: DeferredHandle, options?: ModelsDeferredFetchOptions): Promise<AssistantMessage>;
    cancelDeferred(model: Model<Api>, handle: DeferredHandle, options?: ModelsDeferredCancelOptions): Promise<void>;
}
export {};
//# sourceMappingURL=model-runtime-streaming.d.ts.map