import type { ModuleDependencies } from '../../../modules/pipeline/interfaces/pipeline-interfaces.js';
import type { PipelineExecutionInput, PipelineExecutionResult } from '../../handlers/types.js';
import type { HubPipeline, ProviderHandle } from './types.js';
import { type ProviderFailureClassification } from '../../../providers/core/runtime/provider-failure-policy.js';
import type { StatsManager } from './stats-manager.js';
import { type SseWrapperErrorInfo } from './executor/sse-error-handler.js';
import { type AntigravityRetrySignal } from './executor/request-retry-helpers.js';
import { type ProviderTrafficGovernorLike } from './provider-traffic-governor.js';
export type RequestExecutorDeps = {
    runtimeManager: {
        resolveRuntimeKey(providerKey?: string, fallback?: string): string | undefined;
        getHandleByRuntimeKey(runtimeKey?: string): ProviderHandle | undefined;
    };
    getHubPipeline(): HubPipeline | null;
    getModuleDependencies(): ModuleDependencies;
    logStage(stage: string, requestId: string, details?: Record<string, unknown>): void;
    stats: StatsManager;
    trafficGovernor?: ProviderTrafficGovernorLike;
    onRequestStart?: (args: {
        requestId: string;
        metadata: Record<string, unknown>;
    }) => void | Promise<void>;
    onRequestEnd?: (args: {
        requestId: string;
    }) => void | Promise<void>;
};
export interface RequestExecutor {
    execute(input: PipelineExecutionInput): Promise<PipelineExecutionResult>;
}
export type { SseWrapperErrorInfo };
type RetryErrorSnapshot = {
    statusCode?: number;
    errorCode?: string;
    upstreamCode?: string;
    reason: string;
};
type RetryPayloadSeed = {
    mode: 'serialized';
    serializedPayload: string;
} | {
    mode: 'snapshot';
    snapshotPayload: Record<string, unknown>;
} | {
    mode: 'none';
};
declare function readString(value: unknown): string | undefined;
declare function extractRetryErrorSnapshot(error: unknown): RetryErrorSnapshot;
declare function prepareRequestPayloadRetrySeed(payload: unknown): RetryPayloadSeed;
declare function resolveOriginalRequestForResponseConversion(seed: RetryPayloadSeed): Record<string, unknown> | undefined;
declare function truncateReason(reason: string, maxLength?: number): string;
type RequestExecutorProviderErrorStage = 'provider.runtime_resolve' | 'provider.send' | 'host.response_contract' | 'host.stopless_contract' | 'provider.followup' | 'provider.sse_decode' | 'provider.http';
type RequestExecutorProviderErrorClassification = ProviderFailureClassification;
declare function resolveRequestExecutorProviderErrorClassification(args: {
    error: unknown;
    retryError: RetryErrorSnapshot;
    stage?: RequestExecutorProviderErrorStage;
}): RequestExecutorProviderErrorClassification | undefined;
declare function isLastAvailableProvider429(args: {
    providerKey?: string;
    routePool?: string[];
    excludedProviderKeys: Set<string>;
    retryError: RetryErrorSnapshot;
}): boolean;
declare function shouldApplyProviderTransportBackoff(args: {
    error: unknown;
    retryError: RetryErrorSnapshot;
    stage?: RequestExecutorProviderErrorStage;
}): boolean;
declare function resolveRequestExecutorProviderErrorReportPlan(args: {
    error: unknown;
    retryError: RetryErrorSnapshot;
    fallbackStage: RequestExecutorProviderErrorStage;
}): {
    errorCode?: string;
    upstreamCode?: string;
    statusCode?: number;
    stageHint: RequestExecutorProviderErrorStage;
};
declare function isHealthNeutralProviderError(args: {
    stage: RequestExecutorProviderErrorStage;
    error?: unknown;
    errorCode?: string;
    upstreamCode?: string;
    statusCode?: number;
    classification?: RequestExecutorProviderErrorClassification;
}): boolean;
declare function buildRecoverableErrorBackoffKey(args: {
    providerKey?: string;
    runtimeKey?: string;
    statusCode?: number;
    errorCode?: string;
    upstreamCode?: string;
    reason?: string;
}): string;
declare function consumeRecoverableErrorBackoffMs(key: string, args: {
    statusCode?: number;
    errorCode?: string;
    upstreamCode?: string;
    reason?: string;
}): number;
declare function buildProviderTransportBackoffKey(args: {
    providerKey?: string;
    runtimeKey?: string;
}): string | undefined;
declare function consumeProviderTransportBackoffMs(key: string, args: {
    error: unknown;
    statusCode?: number;
}): number;
declare function peekProviderTransportBackoffWaitMs(key: string): number;
declare function clearProviderTransportBackoff(key?: string): void;
type ProviderRetryBackoffPlan = {
    blockingRecoverable: boolean;
    retryBackoffMs: number;
    recoverableBackoffMs: number;
    backoffScope: 'provider' | 'recoverable' | 'attempt';
};
type ProviderRetrySwitchAction = 'exclude_and_reroute' | 'retry_same_provider';
type ProviderRetryBackoffScope = ProviderRetryBackoffPlan['backoffScope'];
type ProviderRetrySwitchPlan = {
    switchAction: ProviderRetrySwitchAction;
    decisionLabel: string;
    runtimeScopeExcluded: string[];
    runtimeScopeExcludedCount: number;
};
type ProviderRetryExclusionPlan = {
    excludedCurrentProvider: boolean;
    antigravityRetrySignal: AntigravityRetrySignal | null;
};
type ProviderRetryEligibilityPlan = {
    shouldRetry: boolean;
    blockingRecoverable: boolean;
};
type ProviderRetryExecutionPlan = {
    shouldRetry: boolean;
    blockingRecoverable: boolean;
    excludedCurrentProvider: boolean;
    holdOnLastAvailable429: boolean;
    retryBackoffMs: number;
    recoverableBackoffMs: number;
    backoffScope?: ProviderRetryBackoffScope;
    retrySwitchPlan?: ProviderRetrySwitchPlan;
    antigravityRetrySignal: AntigravityRetrySignal | null;
};
type ProviderRetryTelemetryPlan = {
    switchLogArgs: {
        requestId: string;
        attempt: number;
        maxAttempts: number;
        providerKey?: string;
        nextAttempt: number;
        reason: string;
        backoffMs?: number;
        statusCode?: number;
        errorCode?: string;
        upstreamCode?: string;
        switchAction: ProviderRetrySwitchAction;
        backoffScope?: ProviderRetryBackoffScope;
        decisionLabel?: string;
        stage?: 'provider.runtime_resolve' | 'provider.send';
        runtimeScopeExcludedCount?: number;
    };
    retryStageDetails: Record<string, unknown>;
    runtimeScopeExcludeDetails?: Record<string, unknown>;
};
type ExcludedProviderReselectionPlan = {
    hasAlternativeCandidate: boolean;
    keepExcludedForNextAttempt: boolean;
};
declare function resolveProviderRetryEligibilityPlan(args: {
    error: unknown;
    retryError: RetryErrorSnapshot;
    attempt: number;
    maxAttempts: number;
    stage?: RequestExecutorProviderErrorStage;
    providerKey?: string;
    promptTooLong?: boolean;
    contextOverflowRetries?: number;
    maxContextOverflowRetries?: number;
    isVerify?: boolean;
    isReauth?: boolean;
    allowAntigravityRecovery?: boolean;
}): ProviderRetryEligibilityPlan;
declare function resolveProviderRetryExecutionPlan(args: {
    error: unknown;
    retryError: RetryErrorSnapshot;
    attempt: number;
    maxAttempts: number;
    stage?: RequestExecutorProviderErrorStage;
    providerKey?: string;
    runtimeKey?: string;
    logicalRequestChainKey: string;
    logicalChainRetryLimitStageRequestId: string;
    routePool?: string[];
    runtimeManager?: RequestExecutorDeps['runtimeManager'];
    excludedProviderKeys: Set<string>;
    recordAttempt: (args: {
        error: boolean;
    }) => void;
    logStage: (stage: string, requestId: string, details?: Record<string, unknown>) => void;
    promptTooLong?: boolean;
    contextOverflowRetries?: number;
    maxContextOverflowRetries?: number;
    isVerify?: boolean;
    isReauth?: boolean;
    allowAntigravityRecovery?: boolean;
    antigravityRetrySignal?: AntigravityRetrySignal | null;
    status?: number;
    forceExcludeCurrentProviderOnRetry?: boolean;
    abortSignal?: AbortSignal;
}): Promise<ProviderRetryExecutionPlan>;
declare function resolveExcludedProviderReselectionPlan(args: {
    providerKey?: string;
    routePool?: string[];
    excludedProviderKeys: Set<string>;
    lastError?: unknown;
}): ExcludedProviderReselectionPlan;
declare function buildProviderRetryTelemetryPlan(args: {
    requestId: string;
    attempt: number;
    maxAttempts: number;
    providerKey?: string;
    retryError: RetryErrorSnapshot;
    excludedProviderKeys: Set<string>;
    routeHint?: string;
    retryExecutionPlan: ProviderRetryExecutionPlan;
    stage: 'provider.runtime_resolve' | 'provider.send';
    runtimeKey?: string;
    promptTooLong?: boolean;
    contextOverflowRetries?: number;
    maxContextOverflowRetries?: number;
}): ProviderRetryTelemetryPlan;
declare function acquireRecoverableRetryWaiterSlotForTests(key: string): {
    key: string;
    activeWaiters: number;
};
declare function releaseRecoverableRetryWaiterSlotForTests(key: string): void;
declare function deriveLogicalRequestChainKey(requestId: string): string;
declare function resetRequestExecutorInternalStateForTests(): void;
declare function peekRecoverableRetryWaitersForTests(key: string): number;
declare function resolveProviderRetryExclusionPlan(args: {
    providerKey?: string;
    status?: number;
    error: unknown;
    classification?: RequestExecutorProviderErrorClassification;
    promptTooLong: boolean;
    isVerify: boolean;
    isReauth: boolean;
    antigravityRetrySignal: AntigravityRetrySignal | null;
    routePool?: string[];
    excludedProviderKeys: Set<string>;
}): ProviderRetryExclusionPlan;
declare function resolveSessionStormBackoffScope(metadata: Record<string, unknown>): string | undefined;
declare function isSessionStormBackoffCandidate(error: unknown): boolean;
declare function consumeSessionStormBackoffMs(key: string): number;
declare function peekSessionStormBackoffWaitMs(key: string): number;
declare function clearSessionStormBackoff(key?: string): void;
declare function detectRetryableEmptyAssistantResponse(body: unknown): {
    reason: string;
    marker: string;
} | null;
export declare class HubRequestExecutor implements RequestExecutor {
    private readonly deps;
    private readonly trafficGovernor;
    constructor(deps: RequestExecutorDeps);
    private logProviderRetrySwitch;
    execute(input: PipelineExecutionInput): Promise<PipelineExecutionResult>;
    private logStage;
    private convertProviderResponseIfNeeded;
}
export declare const __requestExecutorTestables: {
    readString: typeof readString;
    extractRetryErrorSnapshot: typeof extractRetryErrorSnapshot;
    truncateReason: typeof truncateReason;
    isHealthNeutralProviderError: typeof isHealthNeutralProviderError;
    isLastAvailableProvider429: typeof isLastAvailableProvider429;
    shouldApplyProviderTransportBackoff: typeof shouldApplyProviderTransportBackoff;
    buildRecoverableErrorBackoffKey: typeof buildRecoverableErrorBackoffKey;
    consumeRecoverableErrorBackoffMs: typeof consumeRecoverableErrorBackoffMs;
    buildProviderTransportBackoffKey: typeof buildProviderTransportBackoffKey;
    consumeProviderTransportBackoffMs: typeof consumeProviderTransportBackoffMs;
    peekProviderTransportBackoffWaitMs: typeof peekProviderTransportBackoffWaitMs;
    clearProviderTransportBackoff: typeof clearProviderTransportBackoff;
    detectRetryableEmptyAssistantResponse: typeof detectRetryableEmptyAssistantResponse;
    deriveLogicalRequestChainKey: typeof deriveLogicalRequestChainKey;
    resolveSessionStormBackoffScope: typeof resolveSessionStormBackoffScope;
    isSessionStormBackoffCandidate: typeof isSessionStormBackoffCandidate;
    consumeSessionStormBackoffMs: typeof consumeSessionStormBackoffMs;
    peekSessionStormBackoffWaitMs: typeof peekSessionStormBackoffWaitMs;
    clearSessionStormBackoff: typeof clearSessionStormBackoff;
    prepareRequestPayloadRetrySeed: typeof prepareRequestPayloadRetrySeed;
    resolveOriginalRequestForResponseConversion: typeof resolveOriginalRequestForResponseConversion;
    resolveRequestExecutorProviderErrorClassification: typeof resolveRequestExecutorProviderErrorClassification;
    resolveRequestExecutorProviderErrorReportPlan: typeof resolveRequestExecutorProviderErrorReportPlan;
    resolveProviderRetryEligibilityPlan: typeof resolveProviderRetryEligibilityPlan;
    resolveProviderRetryExclusionPlan: typeof resolveProviderRetryExclusionPlan;
    resolveExcludedProviderReselectionPlan: typeof resolveExcludedProviderReselectionPlan;
    resolveProviderRetryExecutionPlan: typeof resolveProviderRetryExecutionPlan;
    buildProviderRetryTelemetryPlan: typeof buildProviderRetryTelemetryPlan;
    acquireRecoverableRetryWaiterSlotForTests: typeof acquireRecoverableRetryWaiterSlotForTests;
    peekRecoverableRetryWaitersForTests: typeof peekRecoverableRetryWaitersForTests;
    releaseRecoverableRetryWaiterSlotForTests: typeof releaseRecoverableRetryWaiterSlotForTests;
    resetRequestExecutorInternalStateForTests: typeof resetRequestExecutorInternalStateForTests;
};
export declare function createRequestExecutor(deps: RequestExecutorDeps): RequestExecutor;