llm-relay 0.80.0 → 0.82.0

package/dist/candidate-runner.d.ts

@@ -40,6 +40,7 @@ import { type QuotaObservation } from "./quota-observation.js";
 import { type FactResetBasis } from "./target-facts.js";
 import { type QuotaDemotionFn } from "./quota-demotion.js";
 import { type LatencyDemotionFn } from "./latency-demotion.js";
+import { type PacingFn } from "./pacing.js";
 import type { HedgeDelayDecision } from "./hedge-trigger.js";
 import { type Settled } from "./hedge-race.js";
 import { type HardCapVerdict } from "./hard-cap.js";
@@ -62,7 +63,13 @@ export interface StickyRequestContext {
     /** The previously stored pin's routing evaluation; null means a new pin may be created. */
     provenance: string | null;
 }
-export type TargetUsability = "live" | "slow" | "credential-fault" | "cooling" | "probation";
+/**
+ * The walk's health bands, best first: `probation` → `live` → `slow` → `paced` →
+ * `credential-fault` → `cooling`. `paced` (2026-09-15, `pacing.ts`) sits behind `slow` because a
+ * slow member most likely answers while one at its stated ceiling most likely 429s — and ahead of
+ * the failure bands because it is healthy, merely full for the moment.
+ */
+export type TargetUsability = "live" | "slow" | "paced" | "credential-fault" | "cooling" | "probation";
 type OutcomeClass = "ok" | "retriable" | "credential" | "client";
 export declare const DEFAULT_WALK_BUDGET_MS = 45000;
 export declare const DEFAULT_STALL_TIMEOUT_MS = 90000;
@@ -80,6 +87,20 @@ export interface CandidateRunnerHandlers {
      * site that omits it silently disables the band there.
      */
     probation?: ProbationFn | null;
+    /**
+     * Evidence that a provider's own roster has moved: a 404 stating that a model THIS RELAY LISTS
+     * does not exist. The request path wires it to `ModelCatalog.noteProviderStale`, which re-fetches
+     * that provider's `/models` behind a per-provider cooldown.
+     *
+     * Optional, like `probation` and for the same reason — hand-built handler literals in tests keep
+     * compiling — and absent reads as "no trigger", which is the pre-existing behaviour: the catalog
+     * waits for its TTL. `createProxy` always sets it.
+     *
+     * ⚠ The handler is handed the attempt, not a provider name, so the containment the trigger needs
+     * — "on a model the catalog currently lists" — is decided where the catalog is, and not by a
+     * caller that would have to re-derive it.
+     */
+    catalogStale?: ((attempt: ResolvedAttempt) => void) | null;
 }
 interface ServedAnnouncementContext {
     readonly target: ResolvedTarget;
@@ -91,6 +112,7 @@ interface ServedAnnouncementContext {
     readonly degraded?: string | null | undefined;
     readonly quotaDemoted?: string | null | undefined;
     readonly latencyDemoted?: string | null | undefined;
+    readonly paced?: string | null | undefined;
     readonly probation?: string | null | undefined;
     readonly hedged?: string | null | undefined;
     readonly paid?: string | null | undefined;
@@ -174,7 +196,7 @@ export declare function probationLabel(spec: string, verdict: ProbationVerdict):
 export declare function probationLabelForAttempt(h: {
     probation?: ProbationFn | null;
 }, attempt: ResolvedAttempt, now: number): string | null;
-export declare function targetUsability(attempt: ResolvedAttempt, breaker: CircuitBreaker, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null): TargetUsability;
+export declare function targetUsability(attempt: ResolvedAttempt, breaker: CircuitBreaker, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null, pacing?: PacingFn | null): TargetUsability;
 export declare function expandCredentialAttempts(targets: readonly ResolvedTarget[]): ResolvedAttempt[];
 export declare function credentialEvidence(attempt: ResolvedAttempt, cfg: Config, breaker: CircuitBreaker, now: number): {
     facts: {
@@ -191,10 +213,11 @@ export declare function credentialEvidence(attempt: ResolvedAttempt, cfg: Config
     quota: QuotaObservation[];
     cost: "free" | "unknown" | "paid";
 };
-export declare function orderDeploymentGroupsByUsability(attempts: readonly ResolvedAttempt[], breaker: CircuitBreaker, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null): {
+export declare function orderDeploymentGroupsByUsability(attempts: readonly ResolvedAttempt[], breaker: CircuitBreaker, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null, pacing?: PacingFn | null): {
     ordered: ResolvedAttempt[];
     quotaDemotedFirst: string | null;
     latencyDemotedFirst: string | null;
+    pacedFirst: string | null;
 };
 export declare class CredentialAttemptTrace {
     private readonly cfg;
@@ -320,6 +343,12 @@ interface WalkExitData {
     errorOrigin?: ErrorOrigin;
     servedBy?: string;
     shouldTryNext?: boolean;
+    /**
+     * The dead stream's classified cause, when the backend stated one — see `stream-commit.ts`
+     * `stopCauseToken`. The WIRE half is already carried by `message`; this is the half that reaches
+     * the metadata log, and it is an enum-like token rather than any part of the backend's words.
+     */
+    streamStopCause?: string | undefined;
 }
 export declare function walkExitHeaders(tracker: Pool429Tracker, sticky: StickyRequestContext | null | undefined, credentialTrace: CredentialAttemptTrace, { errorOrigin, errorType, servedBy, }?: Pick<WalkExitData, "errorOrigin" | "errorType" | "servedBy">): Record<string, string>;
 export declare function endWalk(h: {
@@ -334,7 +363,7 @@ export declare function respondAllCapped(res: ServerResponse, h: {
     hadTools: boolean;
     streamed: boolean;
 }, front: "anthropic" | "openai", tracker: Pool429Tracker, attempts: readonly RequestAttemptLog[]): void;
-export declare function applyStickyOrdering(ordered: ResolvedAttempt[], pinnedSpec: string, breaker: CircuitBreaker, degraded: Set<string> | null, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null): {
+export declare function applyStickyOrdering(ordered: ResolvedAttempt[], pinnedSpec: string, breaker: CircuitBreaker, degraded: Set<string> | null, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null, pacing?: PacingFn | null): {
     targets: ResolvedAttempt[];
     status: string;
 };
@@ -374,11 +403,12 @@ export declare function recordStickySuccess(h: {
  * hedged (`hedge-trigger.ts`: unmeasured IS hedged), so a probation member that hangs costs one
  * hedge, not a timeout — no second mechanism is added here.
  */
-export declare function orderByUsability(attempts: ResolvedAttempt[], breaker?: CircuitBreaker, now?: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null): ResolvedAttempt[];
-export declare function orderByUsabilityTracked(attempts: ResolvedAttempt[], breaker: CircuitBreaker, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null): {
+export declare function orderByUsability(attempts: ResolvedAttempt[], breaker?: CircuitBreaker, now?: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null, pacing?: PacingFn | null): ResolvedAttempt[];
+export declare function orderByUsabilityTracked(attempts: ResolvedAttempt[], breaker: CircuitBreaker, now: number, quotaDemotion?: QuotaDemotionFn | null, costClassOf?: CostClassFn | null, latencyDemotion?: LatencyDemotionFn | null, probation?: ProbationFn | null, pacing?: PacingFn | null): {
     ordered: ResolvedAttempt[];
     quotaDemotedFirst: string | null;
     latencyDemotedFirst: string | null;
+    pacedFirst: string | null;
 };
 /** What one HTTP status means to the walk: how to classify the outcome, and whether the body may
  * carry an eligibility fact worth interpreting. */
@@ -464,14 +494,20 @@ export interface HealthAttempt {
     terminal?: "succeeded" | "failed" | "cancelled";
 }
 export declare function targetIdentity(attempt: ResolvedAttempt): ProviderTargetIdentity;
+/**
+ * Begin the breaker attempt for one egress. `estimatedInputTokens` is REQUIRED, not optional, so
+ * the compiler enumerates both fronts' call sites: it feeds the cell's attempt-start log that
+ * `pacing.ts` counts token windows over, and an optional parameter would let one front silently
+ * pace on requests alone — the one-front gap this repo's history warns about most.
+ */
 export declare function beginHealthAttempt(h: {
     breaker: CircuitBreaker;
-}, resolvedAttempt: ResolvedAttempt, started: number, trace: RequestAttemptTrace, usage: UsageAccumulator, accounting: RequestAccountingState | null): HealthAttempt | null;
+}, resolvedAttempt: ResolvedAttempt, started: number, trace: RequestAttemptTrace, usage: UsageAccumulator, accounting: RequestAccountingState | null, estimatedInputTokens: number): HealthAttempt | null;
 type EligibilityObservation = {
     readonly unknown: boolean;
     readonly scope?: ReturnType<typeof materializeScope>;
 };
-export declare function observeEligibility(attempt: ResolvedAttempt, status: number, retryAfterMs: number | null, body: string): EligibilityObservation;
+export declare function observeEligibility(attempt: ResolvedAttempt, status: number, retryAfterMs: number | null, body: string, h?: Pick<CandidateRunnerHandlers, "catalogStale">): EligibilityObservation;
 export declare function freeOnlyApplies(rule: {
     freeOnly?: boolean;
 }, rerouted: boolean): boolean;
@@ -485,7 +521,7 @@ type InspectedCandidateResponse = {
     response: Response;
     eligibility: EligibilityObservation;
 } | PostHeaderBodyFailure;
-export declare function inspectCandidateResponse(res: Response, attempt: ResolvedAttempt, retryAfterMs: number | null): Promise<InspectedCandidateResponse>;
+export declare function inspectCandidateResponse(res: Response, attempt: ResolvedAttempt, retryAfterMs: number | null, h?: Pick<CandidateRunnerHandlers, "catalogStale">): Promise<InspectedCandidateResponse>;
 export declare function walkOutcomeForResponse(status: number, localFailure: boolean, scope?: EligibilityObservation["scope"]): CredentialWalkOutcome;
 export declare function observeAttemptHeaders(h: {
     breaker: CircuitBreaker;

package/dist/candidate-runner.js

@@ -1,5 +1,5 @@
 import { specOfTarget } from "./benchmarks.js";
-import { CREDENTIAL_HEADER, CREDENTIAL_ATTEMPTS_HEADER, POOL_ATTEMPTS_HEADER, HARD_CAP_HEADER, ERROR_ORIGIN_HEADER, SERVED_BY_HEADER, TOOL_DIALECT_HEADER, UNKNOWN_REFUSAL_HEADER, DEGRADED_HEADER, PAID_HEADER, QUOTA_DEMOTED_HEADER, LATENCY_DEMOTED_HEADER, PROBATION_HEADER, HEDGED_HEADER, dialectRefusalSignalOf, errorOrigin, postHeaderBodyFailure, toolUseIdRewrites, toolCallIdRewrites, thoughtSignatureSentinels, upstreamReportedModel, } from "./backend.js";
+import { CREDENTIAL_HEADER, CREDENTIAL_ATTEMPTS_HEADER, POOL_ATTEMPTS_HEADER, HARD_CAP_HEADER, ERROR_ORIGIN_HEADER, SERVED_BY_HEADER, TOOL_DIALECT_HEADER, UNKNOWN_REFUSAL_HEADER, DEGRADED_HEADER, PAID_HEADER, QUOTA_DEMOTED_HEADER, LATENCY_DEMOTED_HEADER, PROBATION_HEADER, PACED_HEADER, HEDGED_HEADER, dialectRefusalSignalOf, errorOrigin, postHeaderBodyFailure, toolUseIdRewrites, toolCallIdRewrites, thoughtSignatureSentinels, upstreamReportedModel, } from "./backend.js";
 import { STICKY_PROVENANCE_HEADER } from "./session-pin.js";
 import { probeStreamForCommit } from "./stream-commit.js";
 import { DIALECT_REFUSED_DESTRUCTIVE_CODE } from "./tool-dialects.js";
@@ -18,9 +18,10 @@ import { looksLikeRateLimitError, parseStatedRateLimit, recordObservedRateLimit
 import { clearFacts, cooldownUntil, factsFor, recordFact } from "./target-facts.js";
 import { quotaDemotionLabel } from "./quota-demotion.js";
 import { latencyDemotionLabel } from "./latency-demotion.js";
+import { pacingLabel } from "./pacing.js";
 import { raceWithHedge } from "./hedge-race.js";
 import { hardCapLabel } from "./hard-cap.js";
-import { applyResetRule, interpretRefusal, materializeScope, parseStatedResetMs, recordUnknownRefusal, } from "./refusal-interpretation.js";
+import { applyResetRule, interpretRefusal, materializeScope, parseStatedResetMs, recordUnknownRefusal, statesModelDoesNotExist, } from "./refusal-interpretation.js";
 import { DEFAULT_ANTHROPIC_VERSION } from "./config.js";
 import { buildAuthHeaders } from "./authEnv.js";
 import { CONTROL_AUTHORIZATION_HEADER } from "./control-authorization.js";
@@ -124,6 +125,8 @@ export function responseHeadersForTarget(backendRes, ctx) {
         responseHeaders[QUOTA_DEMOTED_HEADER] = ctx.quotaDemoted;
     if (ctx.latencyDemoted)
         responseHeaders[LATENCY_DEMOTED_HEADER] = ctx.latencyDemoted;
+    if (ctx.paced)
+        responseHeaders[PACED_HEADER] = ctx.paced;
     if (ctx.probation)
         responseHeaders[PROBATION_HEADER] = ctx.probation;
     if (ctx.hedged)
@@ -273,7 +276,7 @@ function cooledByQuota(attempt, breaker, quotaDemotion, now) {
     breaker.recordQuotaCooldown(targetIdentity(attempt), spent.resetsAt, now);
     return true;
 }
-export function targetUsability(attempt, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation) {
+export function targetUsability(attempt, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing) {
     const identity = targetIdentity(attempt);
     if (!breaker.isHealthy(identity, now))
         return "cooling";
@@ -283,6 +286,8 @@ export function targetUsability(attempt, breaker, now, quotaDemotion, costClassO
         return "cooling";
     if (breaker.hasCredentialFault(identity, now))
         return "credential-fault";
+    if (pacing?.(attempt, now))
+        return "paced";
     if (latencyDemotion?.(attempt, now))
         return "slow";
     if (probation?.(attempt, now))
@@ -343,15 +348,16 @@ function coolingLiftTime(attempt, breaker, now, costClassOf) {
     }
     return null;
 }
-export function orderDeploymentGroupsByUsability(attempts, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation) {
+export function orderDeploymentGroupsByUsability(attempts, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing) {
     const preferred = groupCredentialAttempts(attempts)[0]?.attempts[0];
     const probationGroups = [];
     const live = [];
     const slow = [];
+    const paced = [];
     const faulted = [];
     const cooling = [];
     for (const group of groupCredentialAttempts(attempts)) {
-        const usability = targetUsability(group.attempts[0], breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation);
+        const usability = targetUsability(group.attempts[0], breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing);
         switch (usability) {
             case "probation":
                 probationGroups.push(group);
@@ -362,6 +368,9 @@ export function orderDeploymentGroupsByUsability(attempts, breaker, now, quotaDe
             case "slow":
                 slow.push(group);
                 break;
+            case "paced":
+                paced.push(group);
+                break;
             case "credential-fault":
                 faulted.push(group);
                 break;
@@ -385,7 +394,17 @@ export function orderDeploymentGroupsByUsability(attempts, breaker, now, quotaDe
             return -1;
         return liftA - liftB;
     });
-    const ordered = [...probationGroups, ...live, ...slow, ...faulted, ...cooling].flatMap((group) => group.attempts);
+    const ordered = [...probationGroups, ...live, ...slow, ...paced, ...faulted, ...cooling].flatMap((group) => group.attempts);
+    let pacedFirst = null;
+    if (preferred !== undefined &&
+        pacing !== undefined &&
+        pacing !== null &&
+        ordered[0] !== undefined &&
+        ordered[0] !== preferred) {
+        const pacedVerdict = pacing(preferred, now);
+        if (pacedVerdict)
+            pacedFirst = pacingLabel(specOfTarget(preferred.target), pacedVerdict);
+    }
     let latencyDemotedFirst = null;
     if (preferred !== undefined &&
         latencyDemotion !== undefined &&
@@ -405,7 +424,7 @@ export function orderDeploymentGroupsByUsability(attempts, breaker, now, quotaDe
         quotaDemotion(preferred, now) !== null) {
         quotaDemotedFirst = quotaDemotionLabel(specOfTarget(preferred.target), quotaDemotion(preferred, now));
     }
-    return { ordered, quotaDemotedFirst, latencyDemotedFirst };
+    return { ordered, quotaDemotedFirst, latencyDemotedFirst, pacedFirst };
 }
 export class CredentialAttemptTrace {
     cfg;
@@ -705,7 +724,8 @@ export function endWalk(h, res, front, walk, attemptTrace, tracker, status, stic
             error: { message: exit.message, type: exit.errorType ?? "api_error" },
         }));
     }
-    h.logger.write(log());
+    const record = log();
+    h.logger.write(exit.streamStopCause ? { ...record, streamStopCause: exit.streamStopCause } : record);
     return false;
 }
 export function respondAllCapped(res, h, ctx, front, tracker, attempts) {
@@ -735,21 +755,21 @@ export function respondAllCapped(res, h, ctx, front, tracker, attempts) {
     res.end(JSON.stringify(body));
     h.logger.write(baseLog(ctx.started, ctx.path, ctx.hadTools, ctx.streamed, 429, "skipped", null, attempts));
 }
-export function applyStickyOrdering(ordered, pinnedSpec, breaker, degraded, now, quotaDemotion, costClassOf, latencyDemotion, probation) {
+export function applyStickyOrdering(ordered, pinnedSpec, breaker, degraded, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing) {
     const groups = groupCredentialAttempts(ordered);
     const pinnedIndex = groups.findIndex((group) => specOfTarget(group.attempts[0].target) === pinnedSpec);
     const pinnedGroup = pinnedIndex < 0 ? undefined : groups[pinnedIndex];
     const pinned = pinnedGroup?.attempts[0];
     if (!pinned || !pinnedGroup)
         return { targets: ordered, status: "bypassed: not-in-pool" };
-    const usability = targetUsability(pinned, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation);
+    const usability = targetUsability(pinned, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing);
     if (usability !== "live")
         return { targets: ordered, status: `bypassed: ${usability}` };
     if (degraded?.has(pinnedSpec)) {
         const hasLiveInBand = groups.some((group) => {
             const candidate = group.attempts[0];
             return !degraded.has(specOfTarget(candidate.target)) &&
-                targetUsability(candidate, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation) === "live";
+                targetUsability(candidate, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing) === "live";
         });
         if (hasLiveInBand)
             return { targets: ordered, status: "bypassed: degraded" };
@@ -777,18 +797,19 @@ export function recordStickySuccess(h, sticky, target, status) {
         return;
     h.stickySessions?.setPin(sticky.key, specOfTarget(target));
 }
-export function orderByUsability(attempts, breaker = globalCircuitBreaker, now = Date.now(), quotaDemotion, costClassOf, latencyDemotion, probation) {
-    const { ordered } = orderByUsabilityTracked(attempts, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation);
+export function orderByUsability(attempts, breaker = globalCircuitBreaker, now = Date.now(), quotaDemotion, costClassOf, latencyDemotion, probation, pacing) {
+    const { ordered } = orderByUsabilityTracked(attempts, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing);
     return ordered;
 }
-export function orderByUsabilityTracked(attempts, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation) {
+export function orderByUsabilityTracked(attempts, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing) {
     const probationMembers = [];
     const live = [];
     const slow = [];
+    const paced = [];
     const faulted = [];
     const cooling = [];
     for (const attempt of attempts) {
-        const usability = targetUsability(attempt, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation);
+        const usability = targetUsability(attempt, breaker, now, quotaDemotion, costClassOf, latencyDemotion, probation, pacing);
         switch (usability) {
             case "probation":
                 probationMembers.push(attempt);
@@ -799,6 +820,9 @@ export function orderByUsabilityTracked(attempts, breaker, now, quotaDemotion, c
             case "slow":
                 slow.push(attempt);
                 break;
+            case "paced":
+                paced.push(attempt);
+                break;
             case "credential-fault":
                 faulted.push(attempt);
                 break;
@@ -822,8 +846,8 @@ export function orderByUsabilityTracked(attempts, breaker, now, quotaDemotion, c
             return -1;
         return liftA - liftB;
     });
-    const ordered = [...probationMembers, ...live, ...slow, ...faulted, ...cooling];
-    return { ordered, quotaDemotedFirst: null, latencyDemotedFirst: null };
+    const ordered = [...probationMembers, ...live, ...slow, ...paced, ...faulted, ...cooling];
+    return { ordered, quotaDemotedFirst: null, latencyDemotedFirst: null, pacedFirst: null };
 }
 export const STATUS_VERDICT_TABLE = Object.freeze({
     400: { outcome: "retriable", carriesEligibilityFact: true },
@@ -1000,9 +1024,9 @@ export function targetIdentity(attempt) {
         base: target.base,
     });
 }
-export function beginHealthAttempt(h, resolvedAttempt, started, trace, usage, accounting) {
+export function beginHealthAttempt(h, resolvedAttempt, started, trace, usage, accounting, estimatedInputTokens) {
     const identity = targetIdentity(resolvedAttempt);
-    const begun = h.breaker.beginAttempt(identity);
+    const begun = h.breaker.beginAttempt(identity, { at: started, estimatedInputTokens });
     if (!begun.ok)
         return null;
     return {
@@ -1147,11 +1171,20 @@ function refusalBodyCandidates(body) {
     }
     return candidates;
 }
-export function observeEligibility(attempt, status, retryAfterMs, body) {
+function statesModelDoesNotExistInAny(status, body) {
+    for (const candidate of refusalBodyCandidates(body)) {
+        if (statesModelDoesNotExist(status, candidate))
+            return true;
+    }
+    return false;
+}
+export function observeEligibility(attempt, status, retryAfterMs, body, h) {
     const { target } = attempt;
     if (target.model === undefined)
         return { unknown: false };
     try {
+        if (statesModelDoesNotExistInAny(status, body))
+            h?.catalogStale?.(attempt);
         let matchedBody = body;
         let verdict = null;
         for (const candidate of refusalBodyCandidates(body)) {
@@ -1202,7 +1235,7 @@ export function resolveReset(interpretation, headerMs, body) {
 export function carriesEligibilityFact(status) {
     return statusVerdict(status).carriesEligibilityFact;
 }
-export async function inspectCandidateResponse(res, attempt, retryAfterMs) {
+export async function inspectCandidateResponse(res, attempt, retryAfterMs, h) {
     const propagatedFailure = postHeaderBodyFailure(res);
     if (propagatedFailure)
         return propagatedFailure;
@@ -1222,7 +1255,7 @@ export async function inspectCandidateResponse(res, attempt, retryAfterMs) {
     observeMaxOutput(status, attempt.target, body);
     observeRateLimit(attempt, status, body);
     const eligibility = carriesEligibilityFact(status) && body
-        ? observeEligibility(attempt, status, retryAfterMs, body)
+        ? observeEligibility(attempt, status, retryAfterMs, body, h)
         : { unknown: false };
     return {
         kind: "response",