@adaptic/utils 0.0.1014 → 0.0.1016

package/dist/types/llm/eval/types.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Types for the LLM migration eval harness.
+ *
+ * Every gate in this harness is INCUMBENT-RELATIVE: the question is never "is
+ * the candidate good" but "is the candidate at least as good as the model it
+ * would replace". That framing is what makes a gate decidable by code from
+ * recorded data, which PD-6 requires — agent judgement never substitutes for a
+ * gate. It also fixes the shape of these types: a golden set that carries no
+ * recorded incumbent baseline has no comparison basis, so it can only render an
+ * `indeterminate` verdict. A gate that passed on missing data would certify
+ * nothing while looking green, which is strictly worse than having no gate.
+ *
+ * @module llm/eval/types
+ */
+import type { LlmAlias, LlmLatencyClass } from "../types";
+/**
+ * The assertion types this harness implements, one per line of Section 6 of
+ * the migration backlog.
+ *
+ * `match` covers both exact-match and field-level F1 because the backlog treats
+ * them as one gate with two measurement choices — a set declares which of the
+ * two its category can be scored on, and the tolerance is the same.
+ */
+export type EvalAssertion = "schema-valid" | "match" | "judge" | "tool-call" | "latency";
+/** The eval-gate categories the route table assigns to each alias. */
+export type EvalGate = "structured-output" | "free-text-judge" | "tool-call" | "none-pinned-judge";
+/** Which measurement a structured set is scored on for the `match` assertion. */
+export type MatchMetric = "exact_match" | "field_f1";
+/** Unit a verdict's numbers are expressed in, so a reader cannot misread a scale. */
+export type MetricUnit = "rate" | "points" | "ms";
+/** One tool call as a provider reported it. */
+export interface RecordedToolCall {
+    /** The function the model asked to call. */
+    readonly name: string;
+    /** The raw argument JSON, kept unparsed because "did it parse" is part of the measurement. */
+    readonly arguments: string;
+}
+/**
+ * One model answer as it was recorded.
+ *
+ * Recorded rather than re-derived: a gate that re-ran the incumbent to obtain
+ * its baseline would compare two different samples of a stochastic process and
+ * call the difference a regression.
+ */
+export interface RecordedResult {
+    /** The answer payload — a parsed object for structured sites, a string for free-text ones. */
+    readonly raw: unknown;
+    /** Wall-clock latency of the call that produced it. */
+    readonly latency_ms: number;
+    /** Tool calls the model asked for, where the site is a tool-call site. */
+    readonly tool_calls?: readonly RecordedToolCall[];
+    /** Pinned-judge score on a 0-100 scale, where the site is judged. */
+    readonly judge_score?: number;
+    /**
+     * Structured retries spent before this answer.
+     *
+     * Section 6 permits exactly one structured retry before the chain falls back,
+     * so the retry count is part of whether a tool call counts as valid — an
+     * answer that took three attempts did not meet the contract even if the third
+     * attempt parsed.
+     */
+    readonly structured_retries?: number;
+}
+/** One graded example: an input, the answer it should produce, and what the incumbent produced. */
+export interface GoldenCase {
+    /** Stable id, so a candidate run can be matched to the case it answered. */
+    readonly id: string;
+    /** The prompt exactly as the call site would send it, post-redaction. */
+    readonly input: string;
+    /** The reference answer the case is graded against. */
+    readonly expected: unknown;
+    /** What the incumbent model returned when the set was captured. */
+    readonly incumbent_result: RecordedResult;
+}
+/** Summary metrics attested for one side of a comparison. */
+export interface BaselineMetrics {
+    /** Fraction of answers that parsed against the set's response shape. */
+    readonly schema_valid_rate?: number;
+    /** Fraction of answers deep-equal to `expected`. */
+    readonly exact_match_rate?: number;
+    /** Field-level F1 against `expected`, on a 0-100 point scale. */
+    readonly field_f1?: number;
+    /** Mean pinned-judge score, on a 0-100 point scale. */
+    readonly judge_score?: number;
+    /** Fraction of cases whose tool call was valid within the permitted retry budget. */
+    readonly valid_call_rate?: number;
+    /** p95 latency across the set. */
+    readonly latency_p95_ms?: number;
+}
+/**
+ * The attested incumbent baseline for a golden set.
+ *
+ * Attested AND recomputable: the harness recomputes every declared metric from
+ * the per-case `incumbent_result` records and refuses to render a verdict when
+ * the two disagree. A baseline that could be edited independently of the data
+ * it summarises would let a gate be passed by lowering the bar rather than by
+ * meeting it.
+ */
+export interface IncumbentBaseline {
+    /** When the incumbent run was captured. */
+    readonly recorded_at: string;
+    /** Where the traffic came from, so a reader can audit provenance. */
+    readonly source: string;
+    /** The incumbent's model family, recorded for attribution rather than for routing. */
+    readonly model_family: string;
+    /** Number of cases the baseline was computed over. */
+    readonly n: number;
+    /** The attested metrics. */
+    readonly metrics: BaselineMetrics;
+}
+/**
+ * The JSON-shape subset a structured set is validated against.
+ *
+ * A deliberate subset rather than full JSON Schema: the harness adds no
+ * dependency, and every keyword it does honour is one a captured call site
+ * actually uses. An unrecognised keyword is ignored rather than treated as
+ * satisfied, and that is stated here because silent leniency in a validator is
+ * how a schema gate stops separating anything.
+ */
+export interface JsonShape {
+    /** The JSON type this node must have. */
+    readonly type: "object" | "array" | "string" | "number" | "integer" | "boolean";
+    /** Property shapes, for an object node. */
+    readonly properties?: Readonly<Record<string, JsonShape>>;
+    /** Properties that must be present, for an object node. */
+    readonly required?: readonly string[];
+    /** Element shape, for an array node. */
+    readonly items?: JsonShape;
+    /** Permitted values, for a scalar node. */
+    readonly enum?: readonly (string | number | boolean)[];
+}
+/** What a tool-call site's answer must call, and with which arguments. */
+export interface ToolExpectation {
+    /** The function name the model is expected to call. */
+    readonly tool: string;
+    /** Argument keys that must be present in the parsed argument object. */
+    readonly required_arguments: readonly string[];
+}
+/**
+ * A golden set: the durable, per-call-site-category evidence a gate runs on.
+ *
+ * Real sets are captured from PAPER traffic under a redaction profile (W5-01).
+ * The profile is recorded on the set rather than applied ad hoc, because a set
+ * whose redaction rules are not written down cannot be re-derived or audited.
+ */
+export interface GoldenSet {
+    /** Stable set id, unique across the golden-set directory. */
+    readonly id: string;
+    /** The call-site category this set stands for. */
+    readonly call_site_category: string;
+    /** The alias the category routes through. */
+    readonly alias: LlmAlias;
+    /** The eval gate this set enforces; must agree with the alias's route-table gate. */
+    readonly eval_gate: EvalGate;
+    /** Minimum cases below which no verdict is rendered. */
+    readonly min_n: number;
+    /** Named redaction profile applied when the set was captured. */
+    readonly redaction_profile: string;
+    /** The latency class the p95 comparison belongs to; must agree with the route table. */
+    readonly latency_class: LlmLatencyClass;
+    /** Which assertions this set is graded on. */
+    readonly assertions: readonly EvalAssertion[];
+    /** Which match measurement the set is scored on, where `match` is asserted. */
+    readonly match_metric?: MatchMetric;
+    /** The response shape, where `schema-valid` is asserted. */
+    readonly response_shape?: JsonShape;
+    /** The tool contract, where `tool-call` is asserted. */
+    readonly tool_expectation?: ToolExpectation;
+    /** The recorded incumbent baseline every assertion compares against. */
+    readonly incumbent_baseline: IncumbentBaseline;
+    /** The graded cases. */
+    readonly cases: readonly GoldenCase[];
+}
+/**
+ * A candidate model's answers to one golden set.
+ *
+ * Separate from the set because the set is durable and the candidate run is
+ * per-evaluation: swapping the candidate must not require re-capturing the
+ * evidence, or every model comparison would be against a different bar.
+ */
+export interface CandidateRun {
+    /** The golden set these answers belong to. */
+    readonly set_id: string;
+    /** Human-readable identity of the candidate, for the report. */
+    readonly candidate_label: string;
+    /** When the candidate run was produced. */
+    readonly recorded_at: string;
+    /** Answers keyed by golden-case id. */
+    readonly results: Readonly<Record<string, RecordedResult>>;
+}
+/**
+ * The outcome of one assertion.
+ *
+ * A discriminated union with a first-class `indeterminate` arm. Collapsing
+ * "could not decide" into "pass" is the specific failure this shape forecloses:
+ * it is the difference between a gate that is silent about missing evidence and
+ * a gate that certifies its absence.
+ */
+export type Verdict = {
+    readonly kind: "pass";
+    readonly assertion: EvalAssertion;
+    readonly unit: MetricUnit;
+    readonly candidate: number;
+    readonly incumbent: number;
+    readonly n: number;
+    readonly detail: string;
+} | {
+    readonly kind: "fail";
+    readonly assertion: EvalAssertion;
+    readonly unit: MetricUnit;
+    readonly candidate: number;
+    readonly incumbent: number;
+    readonly n: number;
+    readonly reason: string;
+} | {
+    readonly kind: "indeterminate";
+    readonly assertion: EvalAssertion;
+    readonly reason: string;
+};
+/** Whether a set or a whole run cleared its gate. Only `PASSED` permits a merge. */
+export type EvalStatus = "PASSED" | "FAILED";
+/** The graded outcome of one golden set against one candidate run. */
+export interface SetReport {
+    /** The set that was graded. */
+    readonly setId: string;
+    /** The candidate that was graded. */
+    readonly candidateLabel: string;
+    /** One verdict per asserted comparison, in assertion order. */
+    readonly verdicts: readonly Verdict[];
+    /** PASSED only when every verdict is `pass`. */
+    readonly status: EvalStatus;
+}
+/** The graded outcome of every set in one evaluation. */
+export interface RunReport {
+    /** Per-set reports, in the order the sets were evaluated. */
+    readonly sets: readonly SetReport[];
+    /** PASSED only when every set passed and at least one set was graded. */
+    readonly status: EvalStatus;
+    /** Why the run reached its status, for the CI log. */
+    readonly summary: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/llm/eval/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/llm/eval/types.ts"],"names":[],"mappings":"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"}

package/dist/types/llm/fallback-chain.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Ordered execution of an alias's fallback chain (PD-3).
+ *
+ * Every call walks the chain primary -> secondary -> closed incumbent, and each
+ * leg runs under a hard timeout and a circuit breaker. Those three controls are
+ * one mechanism rather than three features: a chain without timeouts never
+ * reaches its second leg, a chain without a breaker pays a dead provider's full
+ * timeout on every call, and a timeout without a chain is just a slower
+ * failure. Timeout cascades are this system's known brown-out mode, which is
+ * why the budget is enforced here — at the only place that knows both the
+ * caller's deadline and how many legs are left to spend it on.
+ *
+ * Nothing here ever substitutes a value for an outcome. When every leg is
+ * exhausted the caller gets a typed error naming each leg and why it failed,
+ * because a default returned in place of an answer is a wrong answer that
+ * nobody is told about.
+ *
+ * @module llm/fallback-chain
+ */
+import type { CircuitBreakerRegistry } from "./circuit-breaker";
+import { UnsupportedCapabilityError } from "./param-matrix";
+import type { AliasAttemptRecord, LlmTransport, LlmTransportRequest, LlmTransportResponse, LlmUsageRecord, ResolvedRoute } from "./types";
+/** What one leg of the chain needs in order to run. */
+export interface ChainLeg {
+    readonly route: ResolvedRoute;
+    /** The transport that will carry this leg. */
+    readonly transport: LlmTransport;
+    /** Provider-normalised parameters, or the error that made this leg unusable. */
+    readonly params: Record<string, unknown> | UnsupportedCapabilityError;
+}
+/** Everything the executor needs for one call. */
+export interface ChainExecution {
+    readonly legs: readonly ChainLeg[];
+    readonly content: string | readonly unknown[];
+    readonly responseFormat: LlmTransportRequest["responseFormat"];
+    readonly breakers: CircuitBreakerRegistry;
+    readonly correlationId?: string;
+    /** The caller's own cancellation, honoured ahead of any per-leg budget. */
+    readonly callerSignal?: AbortSignal;
+    /** Clock, injected so elapsed time is observable in tests without waiting. */
+    readonly now?: () => number;
+    /** Invoked once per leg after it settles, for metrics and shadow comparison. */
+    readonly onAttempt?: (record: AliasAttemptRecord) => void;
+}
+/** Result of walking a chain to a successful leg. */
+export interface ChainOutcome<T> {
+    readonly response: LlmTransportResponse<T>;
+    readonly servedBy: ResolvedRoute;
+    readonly attempts: readonly AliasAttemptRecord[];
+    readonly totalUsage: LlmUsageRecord;
+}
+/**
+ * Thrown when every leg of a chain has been tried and none produced an answer.
+ *
+ * Carries the full attempt record rather than only the last error. The last
+ * error is usually the least informative one — the incumbent timing out says
+ * nothing about why the two legs before it were skipped — and an operator
+ * reading only that would go looking in the wrong place.
+ */
+export declare class ChainExhaustedError extends Error {
+    /** The alias whose chain was exhausted. */
+    readonly alias: string;
+    /** Every leg tried, in order, with its outcome. */
+    readonly attempts: readonly AliasAttemptRecord[];
+    /** Usage spent across the failed attempts, so the spend is still accounted for. */
+    readonly totalUsage: LlmUsageRecord;
+    /**
+     * @param alias The alias.
+     * @param attempts The attempt record.
+     * @param totalUsage Usage spent across all attempts.
+     */
+    constructor(alias: string, attempts: readonly AliasAttemptRecord[], totalUsage: LlmUsageRecord);
+}
+/**
+ * Add two usage records.
+ *
+ * Attribution keeps the LAST attempt's provider and model, because that is the
+ * one that produced the answer the caller is holding, while the token counts
+ * accumulate across every attempt. Charging only the successful attempt would
+ * understate spend by exactly the amount the failures cost — which is the
+ * amount a fallback chain is most likely to run up.
+ *
+ * @param a The running total.
+ * @param b The attempt to add, if any.
+ * @returns The combined usage.
+ */
+export declare function sumUsage(a: LlmUsageRecord, b: LlmUsageRecord | undefined): LlmUsageRecord;
+/**
+ * Walk a chain until a leg answers.
+ *
+ * @param alias The alias being served, for error attribution.
+ * @param execution The call context.
+ * @returns The first successful leg's answer, with the full attempt record.
+ * @throws {ChainExhaustedError} When no leg produced an answer.
+ */
+export declare function executeChain<T>(alias: string, execution: ChainExecution): Promise<ChainOutcome<T>>;
+//# sourceMappingURL=fallback-chain.d.ts.map

package/dist/types/llm/fallback-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-chain.d.ts","sourceRoot":"","sources":["../../../src/llm/fallback-chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAE5D,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,aAAa,EACd,MAAM,SAAS,CAAC;AAWjB,uDAAuD;AACvD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,0BAA0B,CAAC;CACvE;AAED,kDAAkD;AAClD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;IAC/D,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC3D;AAED,qDAAqD;AACrD,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,2CAA2C;IAC3C,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,mDAAmD;IACnD,SAAgB,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAExD,mFAAmF;IACnF,SAAgB,UAAU,EAAE,cAAc,CAAC;IAE3C;;;;OAIG;gBAED,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,UAAU,EAAE,cAAc;CAiB7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,cAAc,EACjB,CAAC,EAAE,cAAc,GAAG,SAAS,GAC5B,cAAc,CAmBhB;AAuID;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,cAAc,GACxB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CA0F1B"}

package/dist/types/llm/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Public surface of the alias-resolving LLM client.
+ *
+ * Everything a consumer needs to make an LLM call is here, and everything it
+ * needs to make one WITHOUT the timeout, breaker and fallback controls is
+ * deliberately not. The client is the only exported way to reach a model, so a
+ * call site cannot bypass the routing policy by importing something lower down.
+ *
+ * @module llm
+ */
+export { callLLMByAlias, configureLlmClient, llmAliases, llmBreakers } from "./alias-client";
+export { ChainExhaustedError, sumUsage, } from "./fallback-chain";
+export type { AliasAttemptRecord } from "./types";
+export { NoServableRouteError, UnknownAliasError, closedIncumbentLeg, gatewayModelNameFor, listAliases, orderedRoutes, resolveChain, routeKeyFor, routeTable, } from "./route-table";
+export type { ResolvedChain, RouteExclusion } from "./route-table";
+export { UnsupportedCapabilityError, normaliseParams, routeSupports } from "./param-matrix";
+export { RateGuardTimeoutError, guardSnapshots, limitsFor, limitsInventory, resetProviderGuards, withProviderGuards, } from "./rate-guard";
+export type { GuardSnapshot, ProviderLimits } from "./rate-guard";
+export { CircuitBreakerRegistry } from "./circuit-breaker";
+export type { BreakerSnapshot, BreakerState } from "./circuit-breaker";
+export { SchemaRetryExhaustedError, buildRetryPrompt, callWithValidation } from "./schema-retry";
+export type { ValidatedOutcome } from "./schema-retry";
+export { StreamProviderError, StreamTruncatedError, collectStream, normaliseAnthropicStream, normaliseOpenAiStream, normaliseStream, } from "./streaming";
+export type { StreamChunk } from "./streaming";
+export { GatewayResponseError, GatewayUnreachableError, createGatewayTransport, } from "./transports/gateway";
+export type { GatewayTransportConfig } from "./transports/gateway";
+export { DirectTransportRefusedError, createDirectTransport, resolveDefaultDirectCaller, } from "./transports/direct";
+export type { DirectCaller, DirectCallerUsage, DirectTransportConfig, } from "./transports/direct";
+export type { AliasCallOptions, AliasCallResult, LlmAlias, LlmAliasBudget, LlmAliasDefinition, LlmClientConfig, LlmCriticality, LlmLatencyClass, LlmModelIdStatus, LlmOpenItem, LlmPriceAnchor, LlmProvider, LlmProviderTier, LlmResponseFormat, LlmRoute, LlmRouteDefaults, LlmRouteParams, LlmRouteRole, LlmRouteTable, LlmToolCall, LlmTransport, LlmTransportRequest, LlmTransportResponse, LlmUsageRecord, LlmValidationOutcome, ResolvedRoute, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/llm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/llm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7F,OAAO,EACL,mBAAmB,EACnB,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEnE,OAAO,EAAE,0BAA0B,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE5F,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACjG,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,QAAQ,EACR,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/types/llm/param-matrix.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Parameter normalisation across providers.
+ *
+ * A caller passes one option bag and the chain may serve it from any of three
+ * providers, so the same request has to be expressible to all of them. Vendors
+ * disagree about more than spelling: some reject a sampling parameter they do
+ * not support with a hard 400 rather than ignoring it, some name the output
+ * cap differently, and reasoning models take an effort knob that non-reasoning
+ * models refuse. Left unnormalised, a fallback would fail on the leg it fell
+ * back to — turning the mechanism that exists to survive an outage into a
+ * second way to fail.
+ *
+ * The rule throughout is that an unsupported parameter is OMITTED, never sent
+ * with a default. Sending a default asserts a value the caller did not choose;
+ * omitting it lets the provider apply its own, which is what "unsupported"
+ * actually means.
+ *
+ * @module llm/param-matrix
+ */
+import type { AliasCallOptions, LlmResponseFormat, ResolvedRoute } from "./types";
+/**
+ * Normalise a caller's options into the exact parameter set one leg accepts.
+ *
+ * @param options The caller's options.
+ * @param route The leg the request is being prepared for.
+ * @param responseFormat The response shape the caller asked for.
+ * @returns Parameters ready to send verbatim.
+ */
+export declare function normaliseParams(options: AliasCallOptions, route: ResolvedRoute, responseFormat: LlmResponseFormat): Record<string, unknown>;
+/**
+ * Thrown when a leg cannot honour a capability the caller requires.
+ *
+ * A distinct type rather than a generic error, because the chain treats it
+ * differently from a provider outage: the leg is not broken, it is simply the
+ * wrong leg for this request, and no retry against it will help.
+ */
+export declare class UnsupportedCapabilityError extends Error {
+    /** The leg that cannot serve the request. */
+    readonly routeKey: string;
+    /** The capability it lacks. */
+    readonly capability: string;
+    /**
+     * @param route The leg.
+     * @param capability The missing capability.
+     */
+    constructor(route: ResolvedRoute, capability: string);
+}
+/**
+ * Whether a leg can serve a request needing the given capabilities at all.
+ *
+ * Used to skip a leg before spending a network round trip on it. Checking
+ * up front rather than reacting to the provider's rejection keeps a
+ * capability mismatch from consuming the caller's latency budget.
+ *
+ * @param route The leg.
+ * @param needs Capabilities the request requires.
+ * @returns Whether the leg is a candidate.
+ */
+export declare function routeSupports(route: ResolvedRoute, needs: {
+    readonly tools?: boolean;
+    readonly jsonSchema?: boolean;
+    readonly vision?: boolean;
+    readonly cacheControl?: boolean;
+}): boolean;
+//# sourceMappingURL=param-matrix.d.ts.map

package/dist/types/llm/param-matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-matrix.d.ts","sourceRoot":"","sources":["../../../src/llm/param-matrix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACd,MAAM,SAAS,CAAC;AAkBjB;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,aAAa,EACpB,cAAc,EAAE,iBAAiB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmDzB;AAsCD;;;;;;GAMG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,6CAA6C;IAC7C,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC,+BAA+B;IAC/B,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC;;;OAGG;gBACgB,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM;CAS5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE;IACL,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC,GACA,OAAO,CAcT"}

package/dist/types/llm/rate-guard.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Client-side rate and concurrency guards, per provider (W4-04).
+ *
+ * A provider's rate limit is enforced at the provider whether or not the client
+ * respects it. The reason to respect it here is what a 429 means once it
+ * arrives: to the fallback chain it is indistinguishable from provider
+ * ill-health, so a client that over-drives a healthy provider will open that
+ * provider's circuit breaker, fail over to a more expensive leg, and keep doing
+ * so — converting a self-inflicted pacing problem into a permanent routing
+ * change nobody chose. Pacing at the client is what keeps the breaker measuring
+ * the provider rather than measuring us.
+ *
+ * Two distinct bounds are applied because they fail differently. The rate bound
+ * (requests per minute) protects the provider's published ceiling. The
+ * concurrency bound protects the caller: a hundred simultaneous in-flight
+ * requests will each wait behind the other ninety-nine at the provider, so
+ * every one of them blows its latency budget and the fan-out produces a hundred
+ * timeouts instead of a queue.
+ *
+ * Limits live in `provider-limits.json`, not here. A rate limit discovered
+ * during an incident should be correctable by config, not by a release.
+ *
+ * @module llm/rate-guard
+ */
+/** Limits for one provider. */
+export interface ProviderLimits {
+    /** Whether these numbers were transcribed from a provider doc or chosen conservatively. */
+    readonly basis: "published" | "conservative-default";
+    readonly requests_per_minute: number;
+    readonly max_concurrent: number;
+    readonly acquire_timeout_ms: number;
+    /** Where a published limit was read from. Null while the basis is a conservative default. */
+    readonly source?: string | null;
+    readonly note?: string;
+}
+/**
+ * Resolve the limits that apply to a provider.
+ *
+ * An unregistered provider falls back to the conservative defaults rather than
+ * to no limit at all. Treating "unknown" as "unlimited" would make every newly
+ * onboarded provider the one most likely to be over-driven, which is exactly
+ * backwards: a new provider is the one whose real ceiling is least understood.
+ *
+ * @param provider The provider key.
+ * @returns Its limits.
+ */
+export declare function limitsFor(provider: string): ProviderLimits;
+/** Every provider with a recorded limit, plus whether it is published or a default. */
+export declare function limitsInventory(): {
+    provider: string;
+    limits: ProviderLimits;
+}[];
+/**
+ * Thrown when a caller could not acquire a slot within its budget.
+ *
+ * Distinguished from a provider failure so the chain does not count it against
+ * route health: the provider was never asked, so nothing was learned about it.
+ */
+export declare class RateGuardTimeoutError extends Error {
+    /** The provider whose guard could not admit the call. */
+    readonly provider: string;
+    /** Which of the two bounds the caller waited on. */
+    readonly bound: "rate" | "concurrency";
+    /**
+     * @param provider The provider.
+     * @param bound Which bound was binding.
+     * @param waitedMs How long the caller waited.
+     */
+    constructor(provider: string, bound: "rate" | "concurrency", waitedMs: number);
+}
+/**
+ * Run a call under a provider's rate and concurrency guards.
+ *
+ * The concurrency permit is taken AFTER the rate token. Taking it first would
+ * let callers hold scarce permits while idling in the rate queue, which
+ * throttles the provider twice over and turns a pacing bound into a deadlock
+ * shaped like slowness.
+ *
+ * `maxWaitMs` bounds how long a caller may queue. It exists because the queue
+ * spends the SAME budget the call itself does: a caller that waits out its whole
+ * deadline in a rate queue has failed just as completely as one that waited on
+ * the provider, and worse, it never reached the fallback chain that could have
+ * answered it. Passing the leg's own timeout keeps one clock governing the
+ * whole attempt.
+ *
+ * @param provider The provider key.
+ * @param call The work to run once admitted.
+ * @param maxWaitMs Ceiling on queue time; the configured guard timeout applies when lower.
+ * @returns The call's result.
+ * @throws {RateGuardTimeoutError} When neither bound admitted the call in time.
+ */
+export declare function withProviderGuards<T>(provider: string, call: () => Promise<T>, maxWaitMs?: number): Promise<T>;
+/** Observable guard state, for dashboards and tests. */
+export interface GuardSnapshot {
+    readonly provider: string;
+    readonly basis: ProviderLimits["basis"];
+    readonly requestsPerMinute: number;
+    readonly maxConcurrent: number;
+    readonly inFlight: number;
+    readonly rateQueueLength: number;
+    readonly concurrencyQueueLength: number;
+    readonly availableTokens: number;
+}
+/**
+ * Inspect the guards currently in use.
+ *
+ * @returns A snapshot per provider that has been used, sorted by provider.
+ */
+export declare function guardSnapshots(): GuardSnapshot[];
+/**
+ * Discard all guard state.
+ *
+ * Exists so a test can start from a known position; a shared process-wide
+ * limiter is otherwise carried between tests and makes their order matter.
+ *
+ * @returns void
+ */
+export declare function resetProviderGuards(): void;
+//# sourceMappingURL=rate-guard.d.ts.map

package/dist/types/llm/rate-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-guard.d.ts","sourceRoot":"","sources":["../../../src/llm/rate-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAYH,+BAA+B;AAC/B,MAAM,WAAW,cAAc;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,sBAAsB,CAAC;IACrD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAYD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAE1D;AAED,uFAAuF;AACvF,wBAAgB,eAAe,IAAI;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,EAAE,CAIhF;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,yDAAyD;IACzD,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC,oDAAoD;IACpD,SAAgB,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC;IAE9C;;;;OAIG;gBACgB,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,QAAQ,EAAE,MAAM;CASrF;AAgID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IACxC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,aAAa,EAAE,CAiBhD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}