@homeflare/distilled-litellm 0.2.0 → 0.4.0

package/src/services/auto_router.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as C from "@distilled.cloud/core/category";
@@ -26,12 +26,15 @@ export interface GetAutoRouterBenchmarksAutoRouterBenchmarksGetRequest {
   start_date?: string;
   /** YYYY-MM-DD UTC, inclusive (defaults to today) */
   end_date?: string;
+  /** Filter to one virtual key token hash */
+  api_key?: string;
 }
 export const GetAutoRouterBenchmarksAutoRouterBenchmarksGetRequest =
   /*@__PURE__*/ S.suspend(() =>
     S.Struct({
       start_date: S.optional(S.String.pipe(T.Query())),
       end_date: S.optional(S.String.pipe(T.Query())),
+      api_key: S.optional(S.String.pipe(T.Query())),
     }).pipe(
       T.Http({ method: "GET", uri: "/auto_router/benchmarks", code: 200 }),
     ),
@@ -112,18 +115,25 @@ export interface AutoRouterBenchmarkGroup {
   avg_session_seconds: number;
   avg_tokens_per_session: number;
   avg_turns_per_session: number;
-  /** spend plus saved_spend: the estimated single-model cost */
-  baseline_spend: number;
+  /** Estimated single-model cost for covered turns only */
+  baseline_spend: number | null;
   cache: AutoRouterCacheStats;
+  /** Recorded LLM classifier cost already included in spend; null when any session turns predate subtotal recording, and zero for an empty window */
+  classifier_cost: number | null;
   /** The auto-router alias requests were sent to */
   router_name: string;
   /** complexity, adaptive or quality */
   router_type: string;
-  /** saved_spend over baseline_spend, as a percentage */
-  saved_pct: number;
-  saved_per_session: number;
-  /** Signed dollars saved versus each router's savings baseline (derived from its hardest tier, or the configured override), from the same per-request savings record the usage tab reads */
-  saved_spend: number;
+  /** Covered savings over covered baseline spend, as a percentage */
+  saved_pct: number | null;
+  /** Average session savings; unavailable unless every turn is covered */
+  saved_per_session: number | null;
+  /** Signed savings for covered turns only; null when traffic has no current estimates */
+  saved_spend: number | null;
+  /** Actual spend, including classifier cost, for covered turns only */
+  savings_estimated_actual_spend: number;
+  /** Turns covered by the current savings estimator; legacy estimates are excluded */
+  savings_estimated_turns: number;
   sessions: number;
   /** What the routed traffic actually cost */
   spend: number;
@@ -136,13 +146,16 @@ export const AutoRouterBenchmarkGroup = /*@__PURE__*/ S.suspend(() =>
     avg_session_seconds: S.Number,
     avg_tokens_per_session: S.Number,
     avg_turns_per_session: S.Number,
-    baseline_spend: S.Number,
+    baseline_spend: S.NullOr(S.Number),
     cache: AutoRouterCacheStats,
+    classifier_cost: S.NullOr(S.Number),
     router_name: S.String,
     router_type: S.String,
-    saved_pct: S.Number,
-    saved_per_session: S.Number,
-    saved_spend: S.Number,
+    saved_pct: S.NullOr(S.Number),
+    saved_per_session: S.NullOr(S.Number),
+    saved_spend: S.NullOr(S.Number),
+    savings_estimated_actual_spend: S.Number,
+    savings_estimated_turns: S.Number,
     sessions: S.Number,
     spend: S.Number,
     tier_turns: S.optional(AutoRouterBenchmarkGroupTierTurnsMap),
@@ -164,14 +177,21 @@ export interface AutoRouterBenchmarkTotals {
   avg_session_seconds: number;
   avg_tokens_per_session: number;
   avg_turns_per_session: number;
-  /** spend plus saved_spend: the estimated single-model cost */
-  baseline_spend: number;
+  /** Estimated single-model cost for covered turns only */
+  baseline_spend: number | null;
   cache: AutoRouterCacheStats;
-  /** saved_spend over baseline_spend, as a percentage */
-  saved_pct: number;
-  saved_per_session: number;
-  /** Signed dollars saved versus each router's savings baseline (derived from its hardest tier, or the configured override), from the same per-request savings record the usage tab reads */
-  saved_spend: number;
+  /** Recorded LLM classifier cost already included in spend; null when any session turns predate subtotal recording, and zero for an empty window */
+  classifier_cost: number | null;
+  /** Covered savings over covered baseline spend, as a percentage */
+  saved_pct: number | null;
+  /** Average session savings; unavailable unless every turn is covered */
+  saved_per_session: number | null;
+  /** Signed savings for covered turns only; null when traffic has no current estimates */
+  saved_spend: number | null;
+  /** Actual spend, including classifier cost, for covered turns only */
+  savings_estimated_actual_spend: number;
+  /** Turns covered by the current savings estimator; legacy estimates are excluded */
+  savings_estimated_turns: number;
   sessions: number;
   /** What the routed traffic actually cost */
   spend: number;
@@ -182,11 +202,14 @@ export const AutoRouterBenchmarkTotals = /*@__PURE__*/ S.suspend(() =>
     avg_session_seconds: S.Number,
     avg_tokens_per_session: S.Number,
     avg_turns_per_session: S.Number,
-    baseline_spend: S.Number,
+    baseline_spend: S.NullOr(S.Number),
     cache: AutoRouterCacheStats,
-    saved_pct: S.Number,
-    saved_per_session: S.Number,
-    saved_spend: S.Number,
+    classifier_cost: S.NullOr(S.Number),
+    saved_pct: S.NullOr(S.Number),
+    saved_per_session: S.NullOr(S.Number),
+    saved_spend: S.NullOr(S.Number),
+    savings_estimated_actual_spend: S.Number,
+    savings_estimated_turns: S.Number,
     sessions: S.Number,
     spend: S.Number,
     turns: S.Number,
@@ -219,6 +242,77 @@ export const AutoRouterBenchmarksResponse = /*@__PURE__*/ S.suspend(() =>
   identifier: "AutoRouterBenchmarksResponse",
 }) as any as S.Schema<AutoRouterBenchmarksResponse>;
 
+export interface GetAutoRouterSessionAutoRouterSessionGetRequest {
+  /** The client session id (x-*-session-id header) the turns were sent under */
+  session_id: string;
+}
+export const GetAutoRouterSessionAutoRouterSessionGetRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      session_id: S.String.pipe(T.Query()),
+    }).pipe(T.Http({ method: "GET", uri: "/auto_router/session", code: 200 })),
+  ).annotate({
+    identifier: "GetAutoRouterSessionAutoRouterSessionGetRequest",
+  }) as any as S.Schema<GetAutoRouterSessionAutoRouterSessionGetRequest>;
+
+/** Covered turns priced against each baseline model; more than one entry means the router's baseline changed mid-session and baseline_spend mixes both */
+export type AutoRouterSessionResponseBaselineModelsMap = {
+  [key: string]: number | undefined;
+};
+export const AutoRouterSessionResponseBaselineModelsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.Number,
+  ) as any as S.Schema<AutoRouterSessionResponseBaselineModelsMap>;
+
+/** One auto-routed session as its own key sees it: what the last turn ran on, and what the session cost against the router's savings baseline (the priciest model in its hardest tier). */
+export interface AutoRouterSessionResponse {
+  /** The savings baseline most covered turns were priced against, recorded turn by turn, so it still names the counterfactual after the router is reconfigured or removed. None when no turn recorded one: rows from before the baseline was recorded, and adaptive and quality routers, which derive no baseline and so report no savings */
+  baseline_model: string | null;
+  /** Covered turns priced against each baseline model; more than one entry means the router's baseline changed mid-session and baseline_spend mixes both */
+  baseline_models: AutoRouterSessionResponseBaselineModelsMap;
+  /** Estimated single-model cost; unavailable unless every turn is covered */
+  baseline_spend: number | null;
+  /** The deployment model the most recent turn was routed to */
+  last_model: string;
+  /** The auto-router alias the session's requests were sent to */
+  router_name: string;
+  /** complexity, adaptive or quality */
+  router_type: string;
+  /** Estimated savings for covered turns only, net of classifier cost */
+  saved_spend: number | null;
+  /** Actual spend, including classifier cost, for covered turns only */
+  savings_estimated_actual_spend: number;
+  /** Estimated single-model cost for covered turns only */
+  savings_estimated_baseline_spend: number | null;
+  /** Turns covered by the current savings estimator; legacy estimates are excluded */
+  savings_estimated_turns: number;
+  session_id: string;
+  /** What the session's routed traffic actually cost, classifier calls included */
+  spend: number;
+  /** Auto-routed turns the rollup has recorded for this session so far */
+  turns: number;
+}
+export const AutoRouterSessionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    baseline_model: S.NullOr(S.String),
+    baseline_models: AutoRouterSessionResponseBaselineModelsMap,
+    baseline_spend: S.NullOr(S.Number),
+    last_model: S.String,
+    router_name: S.String,
+    router_type: S.String,
+    saved_spend: S.NullOr(S.Number),
+    savings_estimated_actual_spend: S.Number,
+    savings_estimated_baseline_spend: S.NullOr(S.Number),
+    savings_estimated_turns: S.Number,
+    session_id: S.String,
+    spend: S.Number,
+    turns: S.Number,
+  }),
+).annotate({
+  identifier: "AutoRouterSessionResponse",
+}) as any as S.Schema<AutoRouterSessionResponse>;
+
 export interface GetShadowEvalJobAutoRouterShadowEvalJobIdGetRequest {
   job_id: string;
 }
@@ -240,47 +334,13 @@ export const GetShadowEvalJobAutoRouterShadowEvalJobIdGetRequest =
 export type ShadowEvalJobResponseDirection = "forward" | "reverse";
 export const ShadowEvalJobResponseDirection = S.String;
 
-/** One key a job shadows, with its own budget and stop state. */
-export interface ShadowEvalJobKeyResponse {
-  /** The hashed virtual key whose traffic this entry scopes */
-  api_key_id: string;
-  /** This key's sampled attempts so far, judged and errored alike, the same count the sampler budgets against max_turns; populated on list and detail responses. Frozen at stopped_at once the key is stamped, so in-flight attempts landing after a stop never reclassify it */
-  attempt_count?: number | null;
-  /** Alias of the shadowed key, resolved from the key row at read time; None when unset or deleted */
-  key_alias?: string | null;
-  /** Masked display name (sk-...) of the shadowed key, resolved at read time like key_alias */
-  key_name?: string | null;
-  /** This key's own USD budget for the eval's shadow and judge spend, independent of its siblings'; None on jobs created before spend budgets existed, which max_turns alone bounds */
-  max_budget?: number | null;
-  /** This key's sample-count ceiling: the whole budget for jobs created before max_budget existed, and the error-loop safety valve otherwise */
-  max_turns: number;
-  /** This key's recorded shadow plus judge spend in USD, the same figure the sampler budgets against max_budget; populated on list and detail responses and frozen at stopped_at exactly like attempt_count */
-  spend?: number | null;
-  /** When this key's slot was stamped free, whether its own budget ran out, the window closed, or an operator stopped the job; status is derived, so a spent budget reads completed even while this is still unset */
-  stopped_at?: string | null;
-}
-export const ShadowEvalJobKeyResponse = /*@__PURE__*/ S.suspend(() =>
-  S.Struct({
-    api_key_id: S.String,
-    attempt_count: S.optional(S.NullOr(S.Number)),
-    key_alias: S.optional(S.NullOr(S.String)),
-    key_name: S.optional(S.NullOr(S.String)),
-    max_budget: S.optional(S.NullOr(S.Number)),
-    max_turns: S.Number,
-    spend: S.optional(S.NullOr(S.Number)),
-    stopped_at: S.optional(S.NullOr(S.String)),
-  }),
-).annotate({
-  identifier: "ShadowEvalJobKeyResponse",
-}) as any as S.Schema<ShadowEvalJobKeyResponse>;
-
-/** The keys whose traffic this job evaluates, and only those keys', each with its own budget */
-export type ShadowEvalJobResponseKeysList = Array<ShadowEvalJobKeyResponse>;
-export const ShadowEvalJobResponseKeysList = /*@__PURE__*/ S.Array(
-  ShadowEvalJobKeyResponse,
-) as any as S.Schema<ShadowEvalJobResponseKeysList>;
+/** Model groups the sampled traffic is narrowed to; empty means every model the targets use */
+export type ShadowEvalJobResponseModelsList = Array<string>;
+export const ShadowEvalJobResponseModelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ShadowEvalJobResponseModelsList>;
 
-/** Judge outcomes for one slice of a job's verdicts (a router tier, or one of the models that served the real arm). */
+/** Judge outcomes for one slice of a job's verdicts: a router tier, one of the models that served the real arm, or one scoped target (embedded on that target's own entry, so slices never need re-joining to a target by id). */
 export interface ShadowEvalSlice {
   avg_judge_confidence: number;
   /** Judged turns litellm's response cache served, excluded from both spends: an adopted router would be served by the same cache, so those turns cost the same either way */
@@ -319,11 +379,11 @@ export const ShadowEvalResultByCurrentModelList = /*@__PURE__*/ S.Array(
   ShadowEvalSlice,
 ) as any as S.Schema<ShadowEvalResultByCurrentModelList>;
 
-/** One slice per scoped key that has judged verdicts, grouped on the raw key hash. Keys the job scopes but has not judged a turn for yet are absent rather than reported as zero */
-export type ShadowEvalResultByKeyList = Array<ShadowEvalSlice>;
-export const ShadowEvalResultByKeyList = /*@__PURE__*/ S.Array(
+/** One slice per router arm, grouped on the router name. Every arm of a multi-router job is judged against the same real responses over the same sampled requests, so these slices compare routers head-to-head: like-for-like win rates and spends on identical traffic. Verdicts from before arm stamping existed count toward the job's own router */
+export type ShadowEvalResultByRouterList = Array<ShadowEvalSlice>;
+export const ShadowEvalResultByRouterList = /*@__PURE__*/ S.Array(
   ShadowEvalSlice,
-) as any as S.Schema<ShadowEvalResultByKeyList>;
+) as any as S.Schema<ShadowEvalResultByRouterList>;
 
 export type ShadowEvalResultByTierList = Array<ShadowEvalSlice>;
 export const ShadowEvalResultByTierList = /*@__PURE__*/ S.Array(
@@ -334,16 +394,16 @@ export const ShadowEvalResultByTierList = /*@__PURE__*/ S.Array(
 export interface ShadowEvalResult {
   /** Sliced by the model that served the real arm: the keys' incumbent models in forward mode, and in reverse the models the router itself picked */
   by_current_model: ShadowEvalResultByCurrentModelList;
-  /** One slice per scoped key that has judged verdicts, grouped on the raw key hash. Keys the job scopes but has not judged a turn for yet are absent rather than reported as zero */
-  by_key: ShadowEvalResultByKeyList;
+  /** One slice per router arm, grouped on the router name. Every arm of a multi-router job is judged against the same real responses over the same sampled requests, so these slices compare routers head-to-head: like-for-like win rates and spends on identical traffic. Verdicts from before arm stamping existed count toward the job's own router */
+  by_router?: ShadowEvalResultByRouterList;
   by_tier: ShadowEvalResultByTierList;
   /** Eligible requests the sampling dice skipped, summed over legs: the judged rows stand for judged + this many requests. None for jobs from before the funnel existed */
   not_sampled_count?: number | null;
   overall_shadow_win_rate_pct: number;
   overall_tie_rate_pct: number;
-  /** USD the real arm billed across all judged turns, cache-served turns excluded */
+  /** USD the real arm billed across all judged turns, cache-served turns excluded. A judged turn is one (request, router arm) verdict, so a multi-router job counts the real response once per arm it was judged against; per-router comparisons read by_router */
   sampled_real_spend?: number;
-  /** USD the shadow arm billed across the same turns, judge excluded, like for like */
+  /** USD the shadow arms billed across the same turns, judge excluded, like for like */
   sampled_shadow_spend?: number;
   /** Sampled requests dropped by the per-pod concurrency cap, so quiet periods are overweighted */
   shed_count?: number | null;
@@ -355,7 +415,7 @@ export interface ShadowEvalResult {
 export const ShadowEvalResult = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
     by_current_model: ShadowEvalResultByCurrentModelList,
-    by_key: ShadowEvalResultByKeyList,
+    by_router: S.optional(ShadowEvalResultByRouterList),
     by_tier: ShadowEvalResultByTierList,
     not_sampled_count: S.optional(S.NullOr(S.Number)),
     overall_shadow_win_rate_pct: S.Number,
@@ -370,11 +430,68 @@ export const ShadowEvalResult = /*@__PURE__*/ S.suspend(() =>
   identifier: "ShadowEvalResult",
 }) as any as S.Schema<ShadowEvalResult>;
 
-/** Three recorded facts, no history-guessing: a stop is stopped_by (the migration backfills it for every job that displayed stopped when the column arrived, so the pre-column population is closed), completion is the window passing or every key spending its budget, and anything else is running. The all-keys-stamped fallback covers only stops written by pre-column pods during a rolling deploy. */
+/** Every auto-router this job runs as a shadow arm. Multi-router jobs sample one slice of traffic and judge every arm against the same real responses */
+export type ShadowEvalJobResponseRouterNamesList = Array<string>;
+export const ShadowEvalJobResponseRouterNamesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ShadowEvalJobResponseRouterNamesList>;
+
+/** Three recorded facts, no history-guessing: a stop is stopped_by (the migration backfills it for every job that displayed stopped when the column arrived, so the pre-column population is closed), completion is the window passing or every target spending its budget, and anything else is running. The all-targets-stamped fallback covers only stops written by pre-column pods during a rolling deploy. */
 export type ShadowEvalJobResponseStatus = "running" | "completed" | "stopped";
 export const ShadowEvalJobResponseStatus = S.String;
 
-/** A shadow-eval job over one or more keys, each with its own budget and stop state; status is derived from stopped_by, the keys' stop and budget state, and ends_at, never stored, so no writer anywhere can produce an inconsistent one. Aggregate fields are populated by the detail endpoint only and stay None on list responses. */
+/** What kind of entity this entry scopes */
+export type ShadowEvalJobTargetResponseTargetType = "key" | "team" | "user";
+export const ShadowEvalJobTargetResponseTargetType = S.String;
+
+/** One target a job shadows (a key, team, or user), with its own budget and stop state. */
+export interface ShadowEvalJobTargetResponse {
+  /** This target's sampled attempts so far, judged and errored alike, the same count the sampler budgets against max_turns; populated on list and detail responses. Frozen at stopped_at once the target is stamped, so in-flight attempts landing after a stop never reclassify it */
+  attempt_count?: number | null;
+  /** Masked display name (sk-...) for key targets, resolved at read time; None for teams and users */
+  key_name?: string | null;
+  /** This target's own USD budget for the eval's shadow and judge spend, independent of its siblings'; None on jobs created before spend budgets existed, which max_turns alone bounds */
+  max_budget?: number | null;
+  /** This target's sample-count ceiling: the whole budget for jobs created before max_budget existed, and the error-loop safety valve otherwise */
+  max_turns: number;
+  /** This target's recorded shadow plus judge spend in USD, the same figure the sampler budgets against max_budget; populated on list and detail responses and frozen at stopped_at exactly like attempt_count */
+  spend?: number | null;
+  /** When this target's slot was stamped free, whether its own budget ran out, the window closed, or an operator stopped the job; status is derived, so a spent budget reads completed even while this is still unset */
+  stopped_at?: string | null;
+  /** Display label resolved from the target's own row at read time: the key's alias, the team's alias, or the user's email; None when unset or deleted */
+  target_alias?: string | null;
+  /** The hashed virtual key, team id, or user id whose traffic this entry scopes */
+  target_id: string;
+  /** What kind of entity this entry scopes */
+  target_type: ShadowEvalJobTargetResponseTargetType;
+  /** This target's own judged-verdict slice; detail endpoint only, None until a turn is judged */
+  verdicts?: ShadowEvalSlice | null;
+}
+export const ShadowEvalJobTargetResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    attempt_count: S.optional(S.NullOr(S.Number)),
+    key_name: S.optional(S.NullOr(S.String)),
+    max_budget: S.optional(S.NullOr(S.Number)),
+    max_turns: S.Number,
+    spend: S.optional(S.NullOr(S.Number)),
+    stopped_at: S.optional(S.NullOr(S.String)),
+    target_alias: S.optional(S.NullOr(S.String)),
+    target_id: S.String,
+    target_type: ShadowEvalJobTargetResponseTargetType,
+    verdicts: S.optional(S.NullOr(ShadowEvalSlice)),
+  }),
+).annotate({
+  identifier: "ShadowEvalJobTargetResponse",
+}) as any as S.Schema<ShadowEvalJobTargetResponse>;
+
+/** The targets whose traffic this job evaluates, and only theirs, each with its own budget */
+export type ShadowEvalJobResponseTargetsList =
+  Array<ShadowEvalJobTargetResponse>;
+export const ShadowEvalJobResponseTargetsList = /*@__PURE__*/ S.Array(
+  ShadowEvalJobTargetResponse,
+) as any as S.Schema<ShadowEvalJobResponseTargetsList>;
+
+/** A shadow-eval job over one or more targets, each with its own budget and stop state; status is derived from stopped_by, the targets' stop and budget state, and ends_at, never stored, so no writer anywhere can produce an inconsistent one. Aggregate fields are populated by the detail endpoint only and stay None on list responses. */
 export interface ShadowEvalJobResponse {
   baseline_model?: string | null;
   created_at: string;
@@ -388,18 +505,23 @@ export interface ShadowEvalJobResponse {
   judge_spend?: number | null;
   /** Verdicts recorded; detail endpoint only */
   judged_count?: number | null;
-  /** The keys whose traffic this job evaluates, and only those keys', each with its own budget */
-  keys: ShadowEvalJobResponseKeysList;
   /** Most recent attempt error; detail endpoint only */
   last_error?: string | null;
+  /** Model groups the sampled traffic is narrowed to; empty means every model the targets use */
+  models?: ShadowEvalJobResponseModelsList;
   /** Stratified verdicts; detail endpoint only */
   results?: ShadowEvalResult | null;
+  /** The first router, kept for callers that predate router_names; derived so the two fields can never disagree. */
   router_name: string;
+  /** Every auto-router this job runs as a shadow arm. Multi-router jobs sample one slice of traffic and judge every arm against the same real responses */
+  router_names: ShadowEvalJobResponseRouterNamesList;
   shadow_percentage: number;
-  /** Three recorded facts, no history-guessing: a stop is stopped_by (the migration backfills it for every job that displayed stopped when the column arrived, so the pre-column population is closed), completion is the window passing or every key spending its budget, and anything else is running. The all-keys-stamped fallback covers only stops written by pre-column pods during a rolling deploy. */
+  /** Three recorded facts, no history-guessing: a stop is stopped_by (the migration backfills it for every job that displayed stopped when the column arrived, so the pre-column population is closed), completion is the window passing or every target spending its budget, and anything else is running. The all-targets-stamped fallback covers only stops written by pre-column pods during a rolling deploy. */
   status: ShadowEvalJobResponseStatus;
   /** The operator who stopped the job early, recorded by the stop endpoint; 'unknown' backfilled by migration for jobs that displayed stopped when the column arrived; None when the job ended on its own. Its presence is what makes a job read stopped rather than completed */
   stopped_by?: string | null;
+  /** The targets whose traffic this job evaluates, and only theirs, each with its own budget */
+  targets: ShadowEvalJobResponseTargetsList;
 }
 export const ShadowEvalJobResponse = /*@__PURE__*/ S.suspend(() =>
   S.Struct({
@@ -412,28 +534,46 @@ export const ShadowEvalJobResponse = /*@__PURE__*/ S.suspend(() =>
     judge_model: S.String,
     judge_spend: S.optional(S.NullOr(S.Number)),
     judged_count: S.optional(S.NullOr(S.Number)),
-    keys: ShadowEvalJobResponseKeysList,
     last_error: S.optional(S.NullOr(S.String)),
+    models: S.optional(ShadowEvalJobResponseModelsList),
     results: S.optional(S.NullOr(ShadowEvalResult)),
     router_name: S.String,
+    router_names: ShadowEvalJobResponseRouterNamesList,
     shadow_percentage: S.Number,
     status: ShadowEvalJobResponseStatus,
     stopped_by: S.optional(S.NullOr(S.String)),
+    targets: ShadowEvalJobResponseTargetsList,
   }),
 ).annotate({
   identifier: "ShadowEvalJobResponse",
 }) as any as S.Schema<ShadowEvalJobResponse>;
 
+export type ListShadowEvalJobsAutoRouterShadowEvalGetRequestTargetType =
+  | "key"
+  | "team"
+  | "user";
+export const ListShadowEvalJobsAutoRouterShadowEvalGetRequestTargetType =
+  S.String;
+
 export interface ListShadowEvalJobsAutoRouterShadowEvalGetRequest {
-  /** Filter to jobs that shadow this key, alone or alongside others */
-  api_key_id?: string;
+  /** Kind of target to filter on; requires target_id */
+  target_type?:
+    | ListShadowEvalJobsAutoRouterShadowEvalGetRequestTargetType
+    | (string & {});
+  /** Filter to jobs that shadow this target, alone or alongside others */
+  target_id?: string;
   /** Newest jobs to return */
   limit?: number;
 }
 export const ListShadowEvalJobsAutoRouterShadowEvalGetRequest =
   /*@__PURE__*/ S.suspend(() =>
     S.Struct({
-      api_key_id: S.optional(S.String.pipe(T.Query())),
+      target_type: S.optional(
+        ListShadowEvalJobsAutoRouterShadowEvalGetRequestTargetType.pipe(
+          T.Query(),
+        ),
+      ),
+      target_id: S.optional(S.String.pipe(T.Query())),
       limit: S.optional(S.Number.pipe(T.Query())),
     }).pipe(
       T.Http({ method: "GET", uri: "/auto_router/shadow_eval", code: 200 }),
@@ -461,7 +601,7 @@ export const ListShadowEvalJobsAutoRouterShadowEvalGetResponse =
     identifier: "ListShadowEvalJobsAutoRouterShadowEvalGetResponse",
   }) as any as S.Schema<ListShadowEvalJobsAutoRouterShadowEvalGetResponse>;
 
-/** The hashed virtual keys whose traffic will be shadowed. Shadow evaluation runs ONLY on these keys' traffic; requests made with any other key are not sampled. Each key carries its own max_budget spend budget, so one key exhausting its budget leaves the others sampling. At most 100 keys per job, which also bounds every read the job's endpoints make. */
+/** Hashed virtual keys whose traffic will be shadowed. Combined with team_ids and user_ids the job needs at least one target and at most 100, which also bounds every read the job's endpoints make. Each target carries its own max_budget spend budget, so one exhausting its budget leaves the others sampling. */
 export type StartShadowEvalAutoRouterShadowEvalStartPostRequestApiKeyIdsList =
   Array<string>;
 export const StartShadowEvalAutoRouterShadowEvalStartPostRequestApiKeyIdsList =
@@ -476,9 +616,41 @@ export type StartShadowEvalAutoRouterShadowEvalStartPostRequestDirection =
 export const StartShadowEvalAutoRouterShadowEvalStartPostRequestDirection =
   S.String;
 
+/** Model groups to narrow the sampled traffic to, matched on the group the caller requested and resolved through model_group_alias, so an alias and its target are one name. Empty samples every model the targets use. This ANDs with the targets: a job over a user and one model samples that user's requests on that model across every key they own, and none of their other traffic. Forward jobs only: a reverse job samples exactly the traffic its own router served, which no other model group can name */
+export type StartShadowEvalAutoRouterShadowEvalStartPostRequestModelsList =
+  Array<string>;
+export const StartShadowEvalAutoRouterShadowEvalStartPostRequestModelsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<StartShadowEvalAutoRouterShadowEvalStartPostRequestModelsList>;
+
+/** The auto-routers under evaluation, at most 4. Every sampled request runs through every router listed and each arm is judged independently against the same real response, so routers compare head-to-head on identical traffic. More than one router requires direction 'forward'. After validation this field always carries the full deduplicated set, whichever spelling the caller used */
+export type StartShadowEvalAutoRouterShadowEvalStartPostRequestRouterNamesList =
+  Array<string>;
+export const StartShadowEvalAutoRouterShadowEvalStartPostRequestRouterNamesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<StartShadowEvalAutoRouterShadowEvalStartPostRequestRouterNamesList>;
+
+/** Teams whose traffic will be shadowed, matched on the team every authenticated request resolves to, so a team's JWT-auth and virtual-key traffic are both sampled */
+export type StartShadowEvalAutoRouterShadowEvalStartPostRequestTeamIdsList =
+  Array<string>;
+export const StartShadowEvalAutoRouterShadowEvalStartPostRequestTeamIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<StartShadowEvalAutoRouterShadowEvalStartPostRequestTeamIdsList>;
+
+/** Users whose traffic will be shadowed, matched on the user every authenticated request resolves to across all their teams: JWT requests carrying their subject claim and virtual keys they own */
+export type StartShadowEvalAutoRouterShadowEvalStartPostRequestUserIdsList =
+  Array<string>;
+export const StartShadowEvalAutoRouterShadowEvalStartPostRequestUserIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<StartShadowEvalAutoRouterShadowEvalStartPostRequestUserIdsList>;
+
 export interface StartShadowEvalAutoRouterShadowEvalStartPostRequest {
-  /** The hashed virtual keys whose traffic will be shadowed. Shadow evaluation runs ONLY on these keys' traffic; requests made with any other key are not sampled. Each key carries its own max_budget spend budget, so one key exhausting its budget leaves the others sampling. At most 100 keys per job, which also bounds every read the job's endpoints make. */
-  api_key_ids: StartShadowEvalAutoRouterShadowEvalStartPostRequestApiKeyIdsList;
+  /** Hashed virtual keys whose traffic will be shadowed. Combined with team_ids and user_ids the job needs at least one target and at most 100, which also bounds every read the job's endpoints make. Each target carries its own max_budget spend budget, so one exhausting its budget leaves the others sampling. */
+  api_key_ids?: StartShadowEvalAutoRouterShadowEvalStartPostRequestApiKeyIdsList;
   /** Required when direction is reverse and rejected otherwise: the fixed model the router's own responses are judged against. Must be a plain model rather than another auto-router */
   baseline_model?: string | null;
   /** forward answers 'should this key adopt router_name': it samples the requests the key did NOT route through the router and duplicates them through it. reverse answers 'is the router still worth it for a key already on it': it samples the requests the router did serve and duplicates them against baseline_model. The response the caller received is always the real arm */
@@ -489,18 +661,27 @@ export interface StartShadowEvalAutoRouterShadowEvalStartPostRequest {
   duration_days?: number;
   /** Model used to blindly judge real vs. shadow responses. The judge only compares two answers, so a mid-tier model (Claude Sonnet or GPT-4o class) is the sweet spot: small/nano-class models produce unreliable or malformed verdicts, while frontier reasoning models add cost without changing outcomes. */
   judge_model?: string;
-  /** Per-key USD budget for the eval's own overhead, the shadow-arm and judge calls, priced with the same figures the spend pipeline bills. EACH scoped key samples until its recorded eval spend reaches this, so a job over N keys spends at most about N times max_budget; in-flight samples can overshoot the cap by one sampling cache window */
+  /** Per-target USD budget for the eval's own overhead, the shadow-arm and judge calls, priced with the same figures the spend pipeline bills. EACH scoped target samples until its recorded eval spend reaches this, so a job over N targets spends at most about N times max_budget; in-flight samples can overshoot the cap by one sampling cache window. Every router arm draws from the same per-target budget, so a multi-router job reaches it proportionally sooner */
   max_budget?: number;
-  /** The auto-router under evaluation, in either direction */
-  router_name: string;
-  /** Percentage of the key's requests to duplicate through the router */
+  /** Model groups to narrow the sampled traffic to, matched on the group the caller requested and resolved through model_group_alias, so an alias and its target are one name. Empty samples every model the targets use. This ANDs with the targets: a job over a user and one model samples that user's requests on that model across every key they own, and none of their other traffic. Forward jobs only: a reverse job samples exactly the traffic its own router served, which no other model group can name */
+  models?: StartShadowEvalAutoRouterShadowEvalStartPostRequestModelsList;
+  /** The auto-router under evaluation, in either direction: the single-router spelling of router_names. Provide exactly one of the two fields */
+  router_name?: string | null;
+  /** The auto-routers under evaluation, at most 4. Every sampled request runs through every router listed and each arm is judged independently against the same real response, so routers compare head-to-head on identical traffic. More than one router requires direction 'forward'. After validation this field always carries the full deduplicated set, whichever spelling the caller used */
+  router_names?: StartShadowEvalAutoRouterShadowEvalStartPostRequestRouterNamesList;
+  /** Percentage of each target's requests to duplicate through the router */
   shadow_percentage: number;
+  /** Teams whose traffic will be shadowed, matched on the team every authenticated request resolves to, so a team's JWT-auth and virtual-key traffic are both sampled */
+  team_ids?: StartShadowEvalAutoRouterShadowEvalStartPostRequestTeamIdsList;
+  /** Users whose traffic will be shadowed, matched on the user every authenticated request resolves to across all their teams: JWT requests carrying their subject claim and virtual keys they own */
+  user_ids?: StartShadowEvalAutoRouterShadowEvalStartPostRequestUserIdsList;
 }
 export const StartShadowEvalAutoRouterShadowEvalStartPostRequest =
   /*@__PURE__*/ S.suspend(() =>
     S.Struct({
-      api_key_ids:
+      api_key_ids: S.optional(
         StartShadowEvalAutoRouterShadowEvalStartPostRequestApiKeyIdsList,
+      ),
       baseline_model: S.optional(S.NullOr(S.String)),
       direction: S.optional(
         StartShadowEvalAutoRouterShadowEvalStartPostRequestDirection,
@@ -508,8 +689,20 @@ export const StartShadowEvalAutoRouterShadowEvalStartPostRequest =
       duration_days: S.optional(S.Number),
       judge_model: S.optional(S.String),
       max_budget: S.optional(S.Number),
-      router_name: S.String,
+      models: S.optional(
+        StartShadowEvalAutoRouterShadowEvalStartPostRequestModelsList,
+      ),
+      router_name: S.optional(S.NullOr(S.String)),
+      router_names: S.optional(
+        StartShadowEvalAutoRouterShadowEvalStartPostRequestRouterNamesList,
+      ),
       shadow_percentage: S.Number,
+      team_ids: S.optional(
+        StartShadowEvalAutoRouterShadowEvalStartPostRequestTeamIdsList,
+      ),
+      user_ids: S.optional(
+        StartShadowEvalAutoRouterShadowEvalStartPostRequestUserIdsList,
+      ),
     }).pipe(
       T.Http({
         method: "POST",
@@ -556,6 +749,23 @@ export const getAutoRouterBenchmarksAutoRouterBenchmarksGet: API.OperationMethod
   retry: Retry.Retry,
 }));
 
+export type GetAutoRouterSessionAutoRouterSessionGetError =
+  | UnprocessableEntity
+  | LitellmOpError;
+/** Get Auto Router Session One auto-routed session, for the key that ran it: the model its last turn was routed to and the session's spend against the router's savings baseline. Built for a coding agent's status line or stop hook, so any virtual key may call it and only ever sees rows written under its own key hash. Reads the LiteLLM_AutoRouterSession rollup, which the asynchronous spend flush fills a moment after each turn; a session with no flushed auto-routed turn yet is a 404. The id is bounded the way the writer bounded it, so an oversized client id still finds its row. */
+export const getAutoRouterSessionAutoRouterSessionGet: API.OperationMethod<
+  GetAutoRouterSessionAutoRouterSessionGetRequest,
+  AutoRouterSessionResponse,
+  GetAutoRouterSessionAutoRouterSessionGetError,
+  LitellmOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAutoRouterSessionAutoRouterSessionGetRequest,
+  output: AutoRouterSessionResponse,
+  errors: [UnprocessableEntity],
+  protocol: LitellmProtocol,
+  retry: Retry.Retry,
+}));
+
 export type GetShadowEvalJobAutoRouterShadowEvalJobIdGetError =
   | UnprocessableEntity
   | LitellmOpError;
@@ -576,7 +786,7 @@ export const getShadowEvalJobAutoRouterShadowEvalJobIdGet: API.OperationMethod<
 export type ListShadowEvalJobsAutoRouterShadowEvalGetError =
   | UnprocessableEntity
   | LitellmOpError;
-/** List Shadow Eval Jobs List shadow eval jobs, newest first, each key with its attempt count so status is accurate. Judged counts, spend, and results ride the detail endpoint only. */
+/** List Shadow Eval Jobs List shadow eval jobs, newest first, each target with its attempt count so status is accurate. Judged counts, spend, and results ride the detail endpoint only. */
 export const listShadowEvalJobsAutoRouterShadowEvalGet: API.OperationMethod<
   ListShadowEvalJobsAutoRouterShadowEvalGetRequest,
   ListShadowEvalJobsAutoRouterShadowEvalGetResponse,
@@ -593,7 +803,7 @@ export const listShadowEvalJobsAutoRouterShadowEvalGet: API.OperationMethod<
 export type StartShadowEvalAutoRouterShadowEvalStartPostError =
   | UnprocessableEntity
   | LitellmOpError;
-/** Start Shadow Eval Start a shadow eval: duplicate a sampled slice of one or more keys' live traffic against a second arm, judge the two responses blind, and stratify win rates by tier, by the model that served the real arm, and by key. A forward job answers whether the keys should adopt router_name: it samples the requests the router did not serve and duplicates them through it. A reverse job answers whether a key already on the router still gains from it: it samples the requests the router did serve and duplicates them against baseline_model. A key can hold one active job per direction, so both questions can run at once. Shadow responses are never served to users. Each key samples until its recorded eval spend, the shadow and judge calls' own cost, reaches max_budget dollars, the job's window ends, or the job is stopped, so one key running out of budget does not end sampling for the others; sampling changes propagate to pods within about 10 seconds. Shadow and judge calls bill to the shadowed key but are excluded from request counts and auto-router adoption metrics. */
+/** Start Shadow Eval Start a shadow eval: duplicate a sampled slice of one or more targets' live traffic against a second arm, judge the two responses blind, and stratify win rates by tier, by the model that served the real arm, and by target. A target is a virtual key, a team, or a user. Team and user targets match on the identity every request resolves to at auth time, so they cover JWT-authenticated traffic, which presents no virtual key; a user target samples that user's traffic across all their teams, whether it arrives on a JWT or a key they own. models narrows every target to requests for those model groups, so a user plus one model samples that user's traffic on that model across every key they own; it is forward-only, since a reverse job already samples exactly the traffic its own router served. A forward job answers whether the targets should adopt router_name: it samples the requests the router did not serve and duplicates them through it. A reverse job answers whether a target already on the router still gains from it: it samples the requests the router did serve and duplicates them against baseline_model. A target can hold one active job per direction, so both questions can run at once, and a request matching several jobs' targets (say its key and its team) is sampled by each, separately budgeted. Shadow responses are never served to users. Each target samples until its recorded eval spend, the shadow and judge calls' own cost, reaches max_budget dollars, the job's window ends, or the job is stopped, so one target running out of budget does not end sampling for the others; sampling changes propagate to pods within about 10 seconds. Shadow and judge calls bill to the sampled request's own identity but are excluded from request counts and auto-router adoption metrics. */
 export const startShadowEvalAutoRouterShadowEvalStartPost: API.OperationMethod<
   StartShadowEvalAutoRouterShadowEvalStartPostRequest,
   ShadowEvalJobResponse,
@@ -610,7 +820,7 @@ export const startShadowEvalAutoRouterShadowEvalStartPost: API.OperationMethod<
 export type StopShadowEvalJobAutoRouterShadowEvalJobIdStopPostError =
   | UnprocessableEntity
   | LitellmOpError;
-/** Stop Shadow Eval Job Stop an active shadow eval job, every key it scopes at once. Attempts are kept; sampling halts within ~10s. Keys that already stopped on their own budget keep the stopped_at they earned. The statement is the whole state machine: it claims the job only while a leg still samples inside the window with no stop recorded, so a racing operator, a same-instant budget spend, and a repeat stop all read the same 400 with the status the job actually holds. */
+/** Stop Shadow Eval Job Stop an active shadow eval job, every target it scopes at once. Attempts are kept; sampling halts within ~10s. Targets that already stopped on their own budget keep the stopped_at they earned. The statement is the whole state machine: it claims the job only while a leg still samples inside the window with no stop recorded, so a racing operator, a same-instant budget spend, and a repeat stop all read the same 400 with the status the job actually holds. */
 export const stopShadowEvalJobAutoRouterShadowEvalJobIdStopPost: API.OperationMethod<
   StopShadowEvalJobAutoRouterShadowEvalJobIdStopPostRequest,
   ShadowEvalJobResponse,

package/src/services/batch.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as C from "@distilled.cloud/core/category";

package/src/services/beta_agents.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.100.0 — see README). Do not edit.
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (pinned litellm-openapi @ 1.103.0 — see README). Do not edit.
 import * as S from "@distilled.cloud/core/schema";
 import * as API from "@distilled.cloud/core/api";
 import * as T from "../traits.ts";