import type { AliasEvent, PromotionEligibility } from '../calibration/types.js'; import type { DecisionResult } from '../types.js'; import type { DecisionTelemetryHook } from '../telemetry/types.js'; import { type BoundedDecisionMetrics } from '../telemetry/metrics.js'; import { type EnsemblePolicyValidationOptions } from './contract.js'; import type { ChampionChallengerRolePin, DecisionChampionChallenger, DecisionDriftResponse, DecisionEnsembleAggregate, DecisionEnsembleIntegrityReport, DecisionEnsemblePolicy, DriftResponseAction, DriftResponseDecision, DriftSignal, EnsembleBudgetPlan, EnsembleDigest, EnsembleMember, EnsembleMemberResult, PairedDeltaObservation } from './types.js'; export declare class EnsembleRuntimeError extends Error { readonly reason: string; constructor(message: string, reason: string); } export interface EnsembleMemberDispatchRequest { policy: DecisionEnsemblePolicy; policyDigest: EnsembleDigest; member: EnsembleMember; sampleIndex: number; invocationId: string; deadlineEpochMs: number; signal: AbortSignal; /** Hard per-call limits: this sample's reservation. The ensemble ceilings hold only when the * dispatcher enforces them; reported usage above them is a budget violation that stops dispatch. */ limits: { attempts: number; tokens: number; costMicros: number; }; } export interface EnsembleRuntimeTelemetry { hook?: DecisionTelemetryHook; metrics?: BoundedDecisionMetrics; traceId?: string; parentSpanId?: string | null; } export interface EnsembleExecutionOptions { enabled?: boolean; invocationId: string; dispatch: (request: EnsembleMemberDispatchRequest) => Promise; hostCeilings?: EnsemblePolicyValidationOptions['hostCeilings']; calibrationPins?: EnsemblePolicyValidationOptions['calibrationPins']; authorizeMember?: (member: EnsembleMember) => boolean | Promise; now?: () => number; delay?: (ms: number, signal: AbortSignal) => Promise; signal?: AbortSignal; telemetry?: EnsembleRuntimeTelemetry; } export interface EnsembleExecutionResult { status: 'disabled' | 'completed'; reason: 'disabled' | 'policy-disabled' | 'completed'; policyDigest: EnsembleDigest; budget: EnsembleBudgetPlan; aggregate: DecisionEnsembleAggregate | null; memberResults: EnsembleMemberResult[]; retainedResults: Record; /** Charged spend. Samples without trusted usage (null tokens, timeout, rejection, malformed result) * are charged their full reservation and counted in `unknownUsageSamples`. */ actuals: { attempts: number; tokens: number; costMicros: number; unknownUsageSamples: number; }; } export declare function executeDecisionEnsemble(policyInput: unknown, options: EnsembleExecutionOptions): Promise; export interface ShadowInputItem { id: string; input: unknown; slice?: string; } export interface ChampionChallengerObservation { inputDigest: EnsembleDigest; receiptDigest: EnsembleDigest; quality: number | null; calibration: number | null; riskCoverage: number | null; abstention: number | null; latencyMs: number | null; tokens: number | null; costMicros: number | null; slice: number | null; } export interface ChampionChallengerShadowOptions { enabled?: boolean; invocationId: string; items: readonly ShadowInputItem[]; evaluate: (request: { role: 'champion' | 'challenger'; rolePin: ChampionChallengerRolePin; item: ShadowInputItem; invocationId: string; signal: AbortSignal; }) => Promise; eligibility?: PromotionEligibility; aliasHistory?: readonly AliasEvent[]; now?: () => number; signal?: AbortSignal; telemetry?: EnsembleRuntimeTelemetry; } export interface ChampionChallengerShadowResult { status: 'disabled' | 'completed'; recordDigest: EnsembleDigest; pairedDeltas: PairedDeltaObservation[]; receipts: Array<{ itemId: string; champion: EnsembleDigest; challenger: EnsembleDigest; }>; } export declare function championChallengerInputSetDigest(items: readonly ShadowInputItem[]): EnsembleDigest; /** Shadow binding a #2037/#2048 integrity report must carry at `paired_baseline.championChallengerShadow` * (alongside any upstream paired-baseline fields) for its paired deltas to be promotable. It binds the deltas and per-item receipts of one completed shadow run to the record's * stable identity fields (not its whole digest, which pins the integrity report itself). */ export interface ChampionChallengerShadowBaseline { kind: 'decision-champion-challenger-shadow/v1'; recordId: string; inputSetDigest: EnsembleDigest; thresholdsDigest: EnsembleDigest; championIdentityDigest: EnsembleDigest; challengerIdentityDigest: EnsembleDigest; pairedDeltasDigest: EnsembleDigest; receiptsDigest: EnsembleDigest; } export declare function championChallengerShadowBaseline(recordInput: unknown, shadow: Pick): ChampionChallengerShadowBaseline; export declare function runChampionChallengerShadow(recordInput: unknown, options: ChampionChallengerShadowOptions): Promise; export interface ChampionAliasGateway { aliasHistory(alias: string): readonly AliasEvent[]; /** D09's stored eligibility record, the one `promoteAlias` acts on (`CalibrationRegistry.promotionEligibility`). */ promotionEligibility(eligibilityId: string): PromotionEligibility | null; promoteAlias(eligibilityId: string, at: string): AliasEvent; rollbackAlias(alias: string, targetRevision: number, approvalReference: string, at: string): AliasEvent; } export interface ChampionRunPin { runId: string; alias: string; aliasRevision: number; identityDigest: EnsembleDigest; actualModel: string; } export declare function pinChampionForRun(recordInput: unknown, runId: string): ChampionRunPin; export declare function promoteChampionChallenger(input: { record: unknown; integrityReport: DecisionEnsembleIntegrityReport; eligibility: PromotionEligibility; gateway: ChampionAliasGateway; at: string; telemetry?: EnsembleRuntimeTelemetry; now?: () => number; }): AliasEvent; export declare function rollbackChampionForNewRuns(input: { record: unknown; gateway: ChampionAliasGateway; approvalReference: string; at: string; telemetry?: EnsembleRuntimeTelemetry; now?: () => number; }): AliasEvent; export interface DriftRuntimeHandlers { [action: string]: ((decision: DriftResponseDecision) => void | Promise) | undefined; } export declare function executeDriftResponse(policyInput: DecisionDriftResponse, signal: DriftSignal, handlers?: DriftRuntimeHandlers, telemetry?: EnsembleRuntimeTelemetry, now?: () => number): Promise<{ decision: DriftResponseDecision; executed: DriftResponseAction | null; }>; export declare function preregisterChampionChallengerThresholds(record: DecisionChampionChallenger): DecisionChampionChallenger; //# sourceMappingURL=runtime.d.ts.map