import type { DecisionProjectionPolicy } from './projection.js'; import type { DecisionDefinition } from './types.js'; import { measurePairedMovement, pairedNonInferiority, type PairedDifferenceInterval } from './qualification/quality.js'; export declare const egressLiveDigest: (value: unknown) => `sha256:${string}`; /** Issue-level hard cap. An approval can never authorize more, including across reruns. */ export declare const EGRESS_LIVE_ISSUE_CAP_USD = 2; /** Runtime live opt-in, checked inside `runEgressLiveQualification` before credential or transport use. */ export declare const EGRESS_LIVE_ENV_GATE = "AIWG_DECISION_EGRESS_LIVE"; export declare const EGRESS_LIVE_SEED = "aiwg-2680-egress-v1"; export declare const EGRESS_LIVE_ITEMS_PER_CLASS = 30; export declare const EGRESS_ATTACK_CLASSES: readonly ["obvious-override", "false-authority", "delimiter-break", "fake-system", "unauthorized-label", "irrelevant-flood", "credential-exfiltration"]; export type EgressAttackClass = typeof EGRESS_ATTACK_CLASSES[number]; /** Movement is reported per class and gated on these preregistered slices. */ export declare const EGRESS_REPORTING_SLICES: Readonly>; export declare const EGRESS_LABELS: readonly ["documentation", "runtime", "billing", "other"]; declare const TARGET_LABEL = "billing"; declare const ARMS: readonly ["control", "attacked"]; export type EgressArm = typeof ARMS[number]; export interface EgressLiveInput { message: string; adjacent: Record; } export interface EgressLiveItem { id: string; attackClass: EgressAttackClass; baseIndex: number; expectedLabel: 'documentation' | 'runtime'; targetLabel: typeof TARGET_LABEL; /** reference: in both arms (authorized egress); attack: attacked arm only (authorized egress); excluded: never projected. */ canaries: { reference: string; attack: string; excluded: string; }; control: EgressLiveInput; attacked: EgressLiveInput; } export interface EgressLiveCorpus { schemaVersion: 'egress-live-corpus/v1'; syntheticOnly: true; seed: string; itemsPerClass: number; definition: DecisionDefinition; items: EgressLiveItem[]; } export declare function egressLiveDefinition(): DecisionDefinition; /** Deterministic synthetic corpus: every class uses the same base tickets, each item has unique canaries. */ export declare function generateEgressAttackCorpus(seed?: string, itemsPerClass?: number): EgressLiveCorpus; export declare const EGRESS_LIVE_PRICE_CEILING_USD_PER_MILLION = 0.1; export declare const EGRESS_LIVE_PER_REQUEST_TOKEN_BOUND = 4000; export declare const EGRESS_LIVE_OUTPUT_ALLOWANCE_TOKENS = 256; export declare const EGRESS_LIVE_REQUEST_ENVELOPE_TOKENS = 64; /** Provider-failure policy (amendment after egress-2680-live-01, fixed before any new scores). */ export declare const EGRESS_LIVE_MAX_RETRIES_PER_ARM = 1; export declare const EGRESS_LIVE_MAX_MEASUREMENT_FAILURES_PER_CLASS = 1; export declare const EGRESS_LIVE_RETRYABLE_REASONS: readonly ["invalid-output", "service-error", "overloaded"]; /** Run-level retry cap: one seventh of the planned dispatches (60 for the full corpus), reserved like any dispatch. */ export declare const egressMaxRetriesPerRun: (corpus: EgressLiveCorpus) => number; /** * Only a terminal provider answer that is invalid, a 5xx or an overload is retried, at most once per arm and within * the run cap; an exhausted retry is a measurement failure. Everything else, including any uncertain execution, * rate limiting, authentication or request errors, stops the run. */ export declare function egressRetryDecision(failure: { reason: string; remoteExecution?: string; }, attemptIndex: number, retriesUsed: number, maxRetriesPerRun: number): 'retry' | 'measurement-failure' | 'stop'; /** Frozen before any provider call. Its digest is committed with the source. */ export declare function egressLivePreregistration(corpus: EgressLiveCorpus): { schemaVersion: string; issue: number; parent: number; corpusDigest: `sha256:${string}`; definition: import("./types.js").ArtifactPin; seed: string; itemsPerClass: number; classes: ("obvious-override" | "false-authority" | "delimiter-break" | "fake-system" | "unauthorized-label" | "irrelevant-flood" | "credential-exfiltration")[]; arms: ("control" | "attacked")[]; dispatchOrder: string; targetLabel: string; slices: Readonly>; gatedSlices: string[]; metrics: { movement: { helper: string; interval: string; definition: string; }; attackInducedTargetHit: { helper: string; levelBps: number; maximumRate: number; definition: string; }; correctness: { helper: string; method: string; levelBps: number; nonInferiority: { helper: string; marginBps: number; }; definition: string; }; verdict: string; marginRationale: string; }; privacy: { surfaces: ("export" | "stdout" | "stderr" | "snapshot" | "trace" | "receipt" | "test-report" | "thrown-error" | "activity-record")[]; scannedAfterEveryDispatch: boolean; canaries: string; providerBodies: string; }; credential: { scopedReadsOnly: boolean; decoyMustBeDenied: string; enumerationOperations: number; decoyBeforeCorpus: boolean; }; providerFailurePolicy: { amendment: string; retryableReasons: ("invalid-output" | "overloaded" | "service-error")[]; retryOnlyTerminalResponses: boolean; maxRetriesPerArm: number; maxRetriesPerRun: number; retryAccounting: string; onExhausted: string; maxMeasurementFailuresPerClass: number; measurementFailures: string; stillStopImmediately: string[]; }; stop: { fraction: number; retries: string; conditions: string[]; }; pricing: { priceCeilingUsdPerMillionTokens: number; attestedPriceBoundRequired: boolean; reservation: string; charged: string; perRequestTokenBound: number; outputAllowanceTokens: number; requestEnvelopeTokens: number; estimator: { id: string; version: string; }; }; issueCapUsd: number; automaticPromotion: boolean; }; export type EgressLivePreregistration = ReturnType; export interface EgressLivePriceBound { inputUsdPerMillionTokens: number; outputUsdPerMillionTokens: number; /** Attested flat price per request, or null when the provider bills tokens only. */ perRequestUsd: number | null; evidenceReferences: string[]; approvalReference: string; } /** Highest per-token rate the reservation assumes: never below the preregistered constant ceiling. */ export declare const egressLiveMaxRate: (bound: EgressLivePriceBound | null) => number; /** Worst-case USD micros reserved per request: every bounded token at the max rate plus any per-request price. */ export declare function egressLiveReservationMicros(bound: EgressLivePriceBound | null): number; export interface EgressLiveApproval { schemaVersion: 'egress-live-approval/v1'; approved: true; issue: 2680; securityReviewer: string; privacyOwner: string; approvalReference: string; stagingHost: string; stagingWorkspace: string; runId: string; sourceCommit: string; exactHeadCi: string; /** Requested model and the exact served identity every response must report. */ model: string; servedModel: string; apiRevision: 'v1'; origin: string; region: string; credential: { secretService: string; scopedRef: string; decoyRef: string; resolverConfigDigest: string; }; budget: { requests: number; tokens: number; usd: number; wallClockMs: number; }; /** Operator floor for earlier runs' spend. The runner also scans earlier run records and uses the larger value. */ priorRunsReservedUsd: number; /** Operator-attested provider price, with its evidence. Reservation never uses less than the constant ceiling. */ priceBound: EgressLivePriceBound; minDispatchIntervalMs: number; providerTerms: { retention: string; residency: string; zeroDataRetention: string; evidenceReference: string | null; deploymentRestriction: string; }; corpusDigest: string; preregistrationDigest: string; } export declare const egressPlannedDispatches: (corpus: EgressLiveCorpus) => number; /** Planned dispatches plus the preregistered run-level retry cap; approvals must hold this under every 80% stop. */ export declare const egressWorstCaseDispatches: (corpus: EgressLiveCorpus) => number; /** Rejects an approval that is incomplete, altered, above the issue cap, or cannot fit the whole plan under the 80% stop. */ export declare function validateEgressLiveApproval(approval: EgressLiveApproval, corpus: EgressLiveCorpus): void; export declare class EgressLiveStop extends Error { readonly reason: string; constructor(reason: string); } /** Worst-case reservation before every dispatch. Reservations are never refunded. */ export declare class EgressLiveBudget { private readonly approval; readonly started: number; private readonly now; requests: number; tokens: number; private usdMicros; private readonly perRequestMicros; constructor(approval: Pick, started: number, now?: () => number); get usd(): number; checkClock(): void; reserve(): void; } export interface EgressSecretServiceAuditEntry { seq: number; op: string; ref: string | null; outcome: string; httpStatus: number | null; } export interface EgressLiveHost { /** Approved secret service; receives only a logical reference. Errors carry a `category`, never a message that is kept. */ resolveCredential(reference: string): Promise; /** Sanitized secret-service operations (no values, tokens or locators). Required for the no-enumeration claim. */ audit?(): EgressSecretServiceAuditEntry[]; } export interface EgressCredentialAuditEntry { phase: 'decoy' | 'corpus'; ref: string; outcome: string; } /** * Evaluator-side credential guard. Only `allowedRef` reaches the host; any other request is a scope * violation that stops the run. In the decoy phase a granted secret is zeroed, never used, and stops the run. */ export declare function scopedCredentialResolver(phase: 'decoy' | 'corpus', allowedRef: string, host: EgressLiveHost, audit: EgressCredentialAuditEntry[], onStop: (reason: string) => void, onCredential: (text: string) => void): (reference: string) => Promise; export interface EgressWireRecord { digest: `sha256:${string}`; bytes: number; estimatedTokens: number; } /** * Transport guard. Runs before any byte leaves: refuses unreserved dispatch, excluded-canary egress, * undelivered attacks and over-bound requests. A refused request is never sent. */ export declare function guardEgressTransport(transport: typeof fetch, state: { reserved: () => number; dispatched: number; forbidden: () => readonly string[]; required: () => readonly string[]; onStop: (reason: string) => void; onWire: (wire: EgressWireRecord) => void; }): typeof fetch; export interface EgressLiveRow { itemId: string; attackClass: EgressAttackClass; arm: EgressArm; label: string; servedModel: string; requestId: string | null; inputTokens: number; outputTokens: number; providerReportedUsd: number | null; wire: EgressWireRecord; reservedTokens: number; /** Usage at the attested price, and at the reservation's max rate; both include any attested per-request price. */ attestedUsd: number; ceilingUsd: number; } interface SliceReport { slice: string; classes: readonly string[]; expectedN: number; sampleN: number; complete: boolean; /** Items the provider-failure policy recorded as unmeasured; never in the paired tables. */ measurementFailures: { control: number; attacked: number; total: number; }; withinFailureTolerance: boolean; movement: ReturnType | null; attackInducedTargetHit: { events: number; rate: number | null; wilson: readonly [number, number] | null; maximumRate: number; }; correctness: { interval: PairedDifferenceInterval | null; nonInferiority: ReturnType | null; marginBps: number; }; verdict: 'within-bound' | 'exceeds-bound' | 'insufficient-evidence'; } export interface EgressFailedAttempt { itemId: string; attackClass: EgressAttackClass; arm: EgressArm; attempt: number; reason: string; httpStatus: number | null; requestId: string | null; inputTokens: number | null; outputTokens: number | null; providerReportedUsd: number | null; charged: { attestedUsd: number; ceilingUsd: number; }; } export interface EgressMeasurementFailure { itemId: string; attackClass: EgressAttackClass; arm: EgressArm; attempts: number; reasons: string[]; } /** * Recomputes every preregistered metric from recorded rows. Measurement failures are excluded from the paired * tables and reported per class; a class over the tolerance, or with any item neither paired nor recorded as a * failure, is never within bound. */ export declare function computeEgressLiveMetrics(corpus: EgressLiveCorpus, rows: readonly Pick[], failures?: readonly Pick[]): { schemaVersion: string; preregistrationDigest: `sha256:${string}`; perClass: SliceReport[]; slices: SliceReport[]; verdict: string; }; export type EgressLiveMetrics = ReturnType; export declare function egressLiveProjectionPolicy(approval: Pick): DecisionProjectionPolicy; /** Wire-size and cost projection. Never resolves a credential or touches transport. */ export declare function egressLiveDryRun(corpus?: EgressLiveCorpus, priceBound?: EgressLivePriceBound | null, model?: string): { schemaVersion: string; providerCalls: number; credentialReads: number; corpusDigest: `sha256:${string}`; preregistrationDigest: `sha256:${string}`; classes: 7; itemsPerClass: number; arms: 2; plannedDispatches: number; decoyEvaluations: number; decoyDispatches: number; estimatedInputTokens: number; maximumRequestEstimateTokens: number; outputAllowanceTokens: number; attestedPriceBound: { inputUsdPerMillionTokens: number; outputUsdPerMillionTokens: number; perRequestUsd: number | null; } | null; estimatedUsdAtAttested: number | null; estimatedUsdAtCeiling: number; reservedTokens: number; reservedUsdPerRequest: number; reservedUsd: number; priceCeilingUsdPerMillionTokens: number; reservationRateUsdPerMillionTokens: number; issueCapUsd: number; maxRetriesPerRun: number; worstCaseDispatches: number; worstCaseReservedUsd: number; minimumApprovalBudget: { requests: number; tokens: number; usd: number; }; }; /** * Spend already committed to this issue by earlier runs under the artifact root. A provider run with a summary * counts the larger of its reservation and its charged spend; a run with an approval but no summary (crashed or * interrupted) counts its whole approved budget. Unreadable amounts count as the full issue cap. */ export declare function egressPriorRunSpendUsd(artifactRoot: string, excludeRunId?: string): Promise; export interface EgressLiveOptions { approval: EgressLiveApproval; corpus: EgressLiveCorpus; sourceRoot: string; artifactRoot: string; host: EgressLiveHost; /** Offline seam. Always labelled synthetic and recorded under manifest mode `offline`. */ offlineTransport?: typeof fetch; now?: () => number; sleep?: (ms: number) => Promise; } /** Runs the decoy check, then the paired corpus, then records digest-bound D11 evidence. */ export declare function runEgressLiveQualification(options: EgressLiveOptions): Promise<{ evidenceManifest: string; evidenceDigest: `sha256:${string}`; schemaVersion: string; issue: number; source: string; runId: string; sourceCommit: string; corpusDigest: string; preregistrationDigest: string; frozenInputs: { preregistration: { path: string; digest: `sha256:${string}`; }; corpus: { path: string; digest: `sha256:${string}`; }; approval: { path: string; digest: `sha256:${string}`; }; }; stopped: null; collectionSuccess: boolean; planned: number; dispatched: number; recordedRows: number; reserved: { requests: number; tokens: number; usd: number; }; observed: { inputTokens: number; outputTokens: number; providerReportedUsd: number | null; attestedUsd: number; ceilingUsd: number; }; stopEvidence: { itemId: string; arm: "control" | "attacked"; reason: null; httpStatus: number | null; requestId: string | null; inputTokens: number | null; outputTokens: number | null; providerReportedUsd: number | null; charged: { attestedUsd: number; ceilingUsd: number; }; } | null; priorRunsSpendUsd: number; retries: number; failedAttempts: number; measurementFailures: EgressMeasurementFailure[]; priceBound: { reservationRateUsdPerMillionTokens: number; reservationUsdPerRequest: number; inputUsdPerMillionTokens: number; outputUsdPerMillionTokens: number; /** Attested flat price per request, or null when the provider bills tokens only. */ perRequestUsd: number | null; evidenceReferences: string[]; approvalReference: string; }; credential: { scopedReadsOnly: boolean; decoyOutcome: string; enumerationOperations: number | null; }; privacy: { clean: boolean; affected: ("export" | "stdout" | "stderr" | "snapshot" | "trace" | "receipt" | "test-report" | "thrown-error" | "activity-record")[]; }; movement: { verdict: string; slices: { slice: string; sampleN: number; verdict: "insufficient-evidence" | "within-bound" | "exceeds-bound"; measurementFailures: number; }[]; perClass: { attackClass: string; sampleN: number; measurementFailures: { control: number; attacked: number; total: number; }; withinFailureTolerance: boolean; verdict: "insufficient-evidence" | "within-bound" | "exceeds-bound"; }[]; }; providerTerms: { retention: string; residency: string; zeroDataRetention: string; deploymentRestriction: string; }; cases: { [k: string]: import("./index.js").EvidenceOutcome; }; qualification: string; automaticPromotion: boolean; pending: string[]; elapsedMs: number; }>; export {}; //# sourceMappingURL=egress-live-qualification.d.ts.map