`selectGpuForEstimate` derived `maxContiguous` (the per-replica tensor-parallel
ceiling) from cluster-wide or pool-total values, producing estimates for
hardware the cluster lacks and `tpSize` values that exceed a single node's GPU
count.

- Add `perNodeGpuCount` helper deriving a pool's per-node GPUs as
  `floor(gpuCount / nodeCount)`, since `gpuCount` is summed across nodes
- Validate an explicit `gpuModel` against `capacity.nodePools` and fall
  back to the highest-VRAM pool when the requested model is absent, instead
  of resolving it directly from the static GPU spec table
- Compute `maxContiguous` and `capacityLabel` from the selected pool's
  per-node count rather than `maxContiguousAvailable` / `pool.gpuCount`
- Import `NodePoolInfo` from `@airunway/shared`

Tests:

- Add `GET /api/installation/gpu-throughput` suite covering per-node
  `tpSize` clamping, fallback when the requested model is absent, the
  no-explicit-model path, and the empty-cluster `404`

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

Expired entries in `architectureCache` were left in the map indefinitely, so
over time (many distinct `modelId`/token keys) it could grow unbounded despite
the TTL.

- Delete a cache entry in `getModelArchitecture` when it is found expired,
  keeping the cache bounded by "used within TTL"

Tests:

- Add a `getModelArchitecture` suite covering config.json parsing, fresh
  cache reuse, eviction + re-fetch after the TTL, and the non-ok `undefined`
  fallback

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

`useGpuThroughput`'s react-query `queryKey` did not account for auth state, so a
high-confidence estimate fetched for a gated model while logged in could still
be served from cache after logout — even though the backend can no longer read
`config.json` without the token.

- Add an `'auth' | 'anon'` discriminator (derived from token presence, never
  the token itself) to the `queryKey`, forcing a recompute when switching
  between authenticated and anonymous states

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- Add `doesNotFit` to `GpuThroughputEstimate` and set it when model weights plus
  headroom leave no room for KV cache; render an explicit "Does not fit — no
  room for KV cache" warning instead of a misleading per-chat speed
- Resolve KV context length after fetching model architecture, falling back to
  `maxPositionEmbeddings` (capped at `MAX_INFERRED_CONTEXT_LEN`) so long-context
  HF models are no longer sized against the 4K default
- Add backend route and frontend component tests for both cases

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- Add **Model Weights Precision** and **KV Cache Precision** dropdowns in a new
  "Performance & Precision" section, and move the throughput estimate there from
  the model summary card
- Decouple KV-cache precision from weight quantization: add `bytesPerKvFor`
  (defaults to 2 bytes) and thread `kvCacheDtype` through `api.ts`,
  `useGpuOperator`, and `gpu-throughput-params`
- Feed FP8 into the deployment as `--quantization fp8` / `--kv-cache-dtype fp8`
  engine args for `vllm`/`sglang` only
- Gate FP8 to Hopper (H100/H200) via `gpuSupportsFp8`: downgrade an FP8 KV cache
  to FP16 in the estimate and disable Deploy with a reason on non-Hopper GPUs
- Surface aggregate tokens/sec total in the `ThroughputEstimate` label
- Refactor GPU selection so the backend is the single source of truth: replace
  `pickGpuModel` with `hasEstimableGpu` and stop forwarding `gpuModel` from the
  client
- Add tests for `bytesPerKvFor`, `gpuSupportsFp8`, KV/weight decoupling, and FP8
  gating

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

The backend already picks the estimate GPU (highest per-GPU VRAM); the frontend
no longer forwards `gpuModel`, so the threaded value was dead.

- Delete the deprecated `pickGpuModel()` helper from `gpu-throughput-params.ts`
  and narrow `buildThroughputParamsForGpu`'s gate param to `boolean`
- Replace the `gpuModel?: string` prop with a `gpuPresent?: boolean` presence
  flag across `ModelsPage`, `ModelGrid`, `HfModelSearch`, `ModelCard`, and
  `HfModelCard`
- Source `gpuPresent` from `hasEstimableGpu(detailedCapacity)` in `ModelsPage`

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

A user-supplied `modelId` was interpolated raw into Hugging Face URLs while
forwarding the caller's `X-HF-Token`, so malformed ids (`../../…`, extra
`/segments`, query fragments, or whitespace) could steer authenticated outbound
requests to unintended paths.

- Add `isValidHfRepoId()` + `encodeHfRepoPath()` helpers to `huggingface.ts`
  (1-2 safe segments, no `.`/`..` traversal, ≤96 chars/segment, per-segment
  `encodeURIComponent`)
- Guard and encode both token-forwarding fetches: `getModelArchitecture`
  (returns `undefined` on an invalid id) and `getGgufFiles` (throws)
- Reject at the route edges too: `.refine(isValidHfRepoId)` on the
  `gpu-throughput` query schema and a 400 guard on the greedy
  `/:modelId/gguf-files` route
- Add service + route tests covering traversal/unsafe ids and encoded URLs

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- bound `paramCount` with `.max(9_000_000_000_000)` so out-of-range values are
  rejected with 400 instead of yielding garbage throughput estimates, matching
  the existing `contextLen` and `tpSize` caps
- add a test asserting a `paramCount` above the cap returns 400 and never
  reaches the estimator

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

The backend and frontend each carried their own parameter-count parser that had
drifted (whitespace boundaries, the `illion` suffix, and the backend-only `<
10000` sanity guard), so a fix to one never reached the other. Consolidate on a
single source of truth.

- add canonical `parseParameterCountFromName` and `resolveModelParamCount` to
  `@airunway/shared` (`shared/types/modelParams.ts`), keeping the stricter
  backend parsing behaviour
- rewire `modelCompatibility.ts` to import `parseParameterCountFromName` from
  shared, and drop the now-dead `resolveParamCount` from `gpuPerformance.ts` (no
  production callers remained)
- replace the divergent inline regex in `gpu-throughput-params.ts` with the
  shared `resolveModelParamCount`
- repoint the backend tests to the shared implementation

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

The per-chat tokens/sec estimate used one GPU worth of bandwidth and
ignored `tpSize`, underestimating speed by ~`tpSize×` for multi-GPU
replicas — while the UI tooltip implied the GPU count was already
factored in.

- Scale effective bandwidth by `tpSize × TP_DECODE_EFFICIENCY` (0.85) in
  `estimatePerChatTokensPerSec`; `tpSize=1` reproduces the exact
  single-GPU number
- Thread the resolved `effectiveTpSize` into the per-chat call in the
  `gpu-throughput` route
- Add tests for the TP speedup ratio and the `tpSize=1` regression guard

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

`useGpuThroughput` set no `retry`, so it inherited the global `retry: 3`. A 404
(no cluster GPU pool maps to a known spec) is deterministic, so every model card
scrolled into view fired 1 + 3 = 4 doomed requests.

- Add a status-aware `retry` predicate to the `useGpuThroughput` query: skip
  retries on any 4xx, keep a small budget (`failureCount < 2`) for transient
  5xx/network failures
- Add `useGpuOperator.test.tsx` covering the no-retry path (404/400 fire one
  request) and the 5xx retry path, using a `QueryClient` with retries enabled so
  the per-query override is actually exercised

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

Tighten the loose `string` parameters to the unions already exported alongside
each function, so the validated enum flows through without being widened back to
`string`:

- `bytesPerWeightFor(quantization?: string)` -> `quantization?: Quantization`
- `bytesPerKvFor(dtype?: string)` -> `dtype?: KvCacheDtype`

The runtime switch and `undefined` defaults are unchanged, so behavior is
identical; an invalid value is now a compile-time error at the boundary instead
of silently mapping to the 2-byte default.

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

HuggingFace search cards carry no `minGpus`, so they sent no `tpSize`
and the backend defaulted to tp=1 — making large models spuriously
report "does not fit" while the curated/Deploy tabs showed full
capacity for the same model and cluster.

- Add `deriveTpSizeToFitWeights` in `gpuPerformance.ts`: returns the
  smallest power-of-two TP size whose per-GPU weight shard leaves room
  for a KV cache, bounded by `maxContiguous`; the fit test mirrors
  `estimateConcurrentCapacity`.
- Wire it into the `/gpu-throughput` route so an omitted `tpSize` is
  derived instead of defaulting to 1; an explicit `tpSize` still wins.
- Add tests covering the TP bump, `maxContiguous` cap, single-GPU cap,
  small-model/fp8 stay-at-1, unknown paramCount, headroom-exceeds-VRAM,
  and cross-tab consistency.

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- `setFp8PrecisionEngineArgs` now strips `quantization`/`kv-cache-dtype` only
  when the value is `fp8` (the value the precision dropdown owns), so a user-set
  `awq`/`gptq` from the advanced engine-args editor is no longer clobbered when
  weight precision is not FP8
- add a non-blocking warning on the Deploy page when FP8 is selected but the
  throughput estimate is absent (errored/404), so an unsupported `fp8` flag is
  not submitted silently on hardware of unknown capability
- add unit tests for `setFp8PrecisionEngineArgs`

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- correct `formatCount` doc example: `18234` formats to `"18k"` (not `"18.2k"`),
  since values `>= 10000` drop the decimal
- document that `TP_DECODE_EFFICIENCY` (0.85) is a flat factor and is optimistic
  for large TP groups, where the per-GPU haircut grows with `tpSize` and slower
  interconnect
- replace the dead `apiGroup` ternary (both branches returned `''`) with a
  direct `''` and a note that the real CRD group isn't stored on the
  `InferenceProviderConfig`

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

Addresses review findings in the GPU throughput estimator:

- `selectGpuForEstimate()` and `gpuSupportsFp8()` now use strict GPU lookups
  (`normalizeKnownGpuModel`/`getKnownGpuInfo`); an unknown GPU label is skipped
  or returns a `404` instead of being silently estimated as an `A10` with wrong
  speed and FP8 numbers
- the `/gpu-throughput` query schema no longer rejects a non-HF `modelId`; the
  handler gates the token-bearing HF fetch on `isValidHfRepoId()`, so a
  curated/custom id degrades to a bandwidth-only estimate from `paramCount`
  instead of a hard `400`
- `getModelArchitecture()` reads transformer dimensions from nested
  `text_config`/`llm_config`/`language_config`, so multimodal and composite
  models yield high-confidence concurrency estimates instead of per-chat-only
- add tests covering unknown-GPU skip/404, non-HF and malformed `modelId`
  degradation, and nested-config parsing

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

The `eslint ^8 → ^10` bump broke `bun run lint` in both workspaces: ESLint v9+
requires a flat `eslint.config.*` (the repo never had one) and removed the
`--ext` flag both scripts used.

- add flat `eslint.config.mjs` to `backend` and `frontend`, linting TypeScript
  via the typescript-eslint `flat/recommended` preset
- add `@typescript-eslint/parser` and `@typescript-eslint/eslint-plugin` to
  backend (it previously declared only `eslint`, so it could not parse its own
  `.ts`); lockfile updated to match
- drop the removed `--ext` flag from both lint scripts and `--max-warnings 0`
  from frontend
- demote pre-existing `no-explicit-any`, `no-unused-vars`, and the newly-enabled
  react-hooks compiler rules to warnings so lint is green and CI-usable, leaving
  the historical backlog visible for incremental burndown

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- surface a non-blocking "model does not fit" warning on the deploy
  page when the high-confidence estimate leaves no room for the KV
  cache; `Deploy` stays enabled since the user may pick more GPUs per
  replica than the estimate assumed, and it is hidden when `fp8Blocked`
  already explains a blocking reason
- step `tpDecodeEfficiency` down by TP group size (1.0 for TP1, 0.85
  for TP2-4, 0.75 for TP>4) instead of a flat 0.85, so large
  tensor-parallel groups crossing NVLink domains are not over-estimated
- add tests for the no-fit warning and the new efficiency tiers

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

Declare the return ref as `React.RefObject<T | null>` so it matches what
`useRef<T>(null)` produces under `@types/react@19`, fixing the TS2322 build
error that broke the `build` and `e2e-frontend` CI checks.

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>

- Replace `React.RefObject` with a type-only `RefObject` import in
  `useInView` so the return type no longer relies on the UMD `React`
  global, which `tsc` may fail to resolve
- Update `useGpuThroughput` JSDoc to note the query gates on
  `paramCount` only, since the GPU model is now chosen server-side

Signed-off-by: Suraj Deshmukh <suraj.deshmukh@microsoft.com>