@mlx-node/server 0.0.7 → 0.0.9

package/dist/session-registry.d.ts

@@ -2,6 +2,18 @@
  * SessionRegistry -- per-model cache holding AT MOST one live
  * `ChatSession` whose native KV state is currently valid.
  *
+ * **Tier-2 `prompt_cache_key` reuse is ON by default** so the server
+ * is compatible with any stateless LLM agent that sends the full
+ * conversation history each turn. The key is caller-controlled and
+ * HMAC-scoped with a boot-time nonce (raw value never stored on the
+ * entry), but two clients that pick the same raw key will still
+ * lease the same warm session — a session-hijack surface in
+ * multi-tenant settings. For multi-tenant deployments, opt out via
+ * `MLX_DISABLE_PROMPT_CACHE_KEY=1` or front the server with an auth
+ * proxy that rewrites or namespaces `prompt_cache_key` per tenant
+ * before it reaches this process. See also the comments on
+ * {@link scopePromptCacheKey}.
+ *
  * Design notes:
  *
  *   - **One registry per model.** Composed alongside each registered
@@ -50,8 +62,8 @@
  *     atomically appends the new user turn, so cold replay is
  *     indistinguishable from a hot hit.
  *
- *   - **TTL.** Default 1800 seconds mirrors `RESPONSE_TTL_SECONDS`
- *     in `packages/server/src/endpoints/responses.ts` so the cached
+ *   - **TTL.** Default 1800 seconds mirrors `DEFAULT_RESPONSE_RETENTION_SECONDS`
+ *     in `packages/server/src/server.ts` so the cached
  *     entry ages out alongside its stored response metadata. With
  *     at most one entry there is no LRU bookkeeping — just a single
  *     expiry check on lookup.
@@ -79,7 +91,53 @@
  *     time. A weaker epoch-token scheme would let the losing
  *     `adopt()` no-op but the native KV would already be wrong.
  */
+import type { ChatConfig } from '@mlx-node/core';
 import { ChatSession, type SessionCapableModel } from '@mlx-node/lm';
+/**
+ * Test-only hook used by the scoping unit tests to simulate a
+ * server restart: resets the module-scoped HMAC nonce (so every
+ * previously stored tier-2 key misses) and clears the silent-miss
+ * dedupe cache so tests can re-exercise the once-per-key diagnostic
+ * path.
+ *
+ * **Not exported from the package's public `index.ts` surface** —
+ * exporting it there would let downstream consumers nuke tier-2
+ * state in production (every stored entry would go unreachable).
+ * Tests reach the function via the deep path
+ * `packages/server/src/session-registry.ts` instead; that import is
+ * deliberately noisy to signal "test-only, do not use from app
+ * code". The `__` prefix is a loud-enough convention for the
+ * ergonomic test path but NOT sufficient for a public package
+ * export.
+ */
+export declare function __resetPromptCacheKeyNonceForTests(): void;
+/**
+ * Test-only probe for the silent-miss dedupe Map's live size. Same
+ * "do not use from app code" rationale as
+ * {@link __resetPromptCacheKeyNonceForTests}; the `__` prefix and the
+ * test-only deep-import path are the load-bearing signals. Exists so
+ * the flooding regression test can assert the FIFO cap actually bounds
+ * the stored set — an invariant that is otherwise unobservable from
+ * outside the module and is NOT implied by the warning count (each
+ * call emits at most one warning regardless of whether the cap works).
+ */
+export declare function __loggedSilentMissKeysSizeForTests(): number;
+/**
+ * Emit a once-per-raw-key stderr debug warning when the caller
+ * supplies a non-empty `prompt_cache_key` but at least one tier-2
+ * prerequisite is missing — the env gate is off, or the key is
+ * shorter than {@link PROMPT_CACHE_KEY_MIN_LENGTH}. The silent-miss
+ * fallback (cold-start as if no key were supplied) is the documented
+ * behaviour but is easy to miss during integration; this nudge
+ * surfaces the cause once per distinct key so operators don't have
+ * to grep source to diagnose a flat `X-Session-Cache: fresh`.
+ *
+ * No-op when `rawKey` is null / undefined / empty (the caller did
+ * not ask for tier-2 at all) or when scoping would succeed (the
+ * gate already accepted the key). Called by the endpoint layer
+ * right after it has decided `effectivePromptCacheKey`.
+ */
+export declare function maybeWarnPromptCacheKeyIneligible(rawKey: string | null | undefined): void;
 /** Constructor options for {@link SessionRegistry}. */
 export interface SessionRegistryOptions {
     /** The model that every session in this registry wraps. Single-model per registry. */
@@ -99,6 +157,25 @@ export interface SessionRegistryOptions {
      * `MLX_MAX_QUEUE_DEPTH_PER_MODEL` env var.
      */
     maxQueueDepth?: number;
+    /**
+     * Optional sampling defaults applied to every `ChatSession` this
+     * registry allocates. Forwarded verbatim into `new ChatSession(model,
+     * { defaultConfig })` so the session's `mergeConfig(overlay)` shallow-
+     * merges per-call config on top. Intended for server operators who
+     * want to pin per-model sampling knobs (temperature, topK, penalties,
+     * etc.) without client cooperation — per-request values from the
+     * OpenAI `/v1/responses` or Anthropic `/v1/messages` body still win
+     * where present because `ChatSession` treats them as an overlay.
+     *
+     * When `undefined`, behaviour is unchanged from the pre-defaults era
+     * (each `new ChatSession(model)` uses an empty `defaultConfig`).
+     */
+    samplingDefaults?: ChatConfig;
+    /**
+     * Optional per-model cap for generated output tokens. Endpoint handlers
+     * apply it after request mapping, before dispatching into native decode.
+     */
+    maxOutputTokens?: number;
 }
 /**
  * Thrown synchronously by {@link SessionRegistry.withExclusive} when
@@ -126,6 +203,14 @@ export declare class SessionRegistry {
     private readonly model;
     private readonly ttlSec;
     private readonly maxQueueDepth;
+    /**
+     * Per-model sampling defaults forwarded into every new `ChatSession`
+     * via its `defaultConfig` constructor option. `undefined` preserves
+     * the pre-defaults behaviour (empty `defaultConfig`). See
+     * {@link SessionRegistryOptions.samplingDefaults}.
+     */
+    private samplingDefaults;
+    private maxOutputTokens;
     /**
      * Number of callers that are currently WAITING for the per-model
      * execution mutex — i.e. have entered `withExclusive` but have not
@@ -181,12 +266,45 @@ export declare class SessionRegistry {
      */
     private execLock;
     constructor(opts: SessionRegistryOptions);
+    /**
+     * Construct a fresh `ChatSession` bound to this registry's model and
+     * pre-seeded with the operator-configured `samplingDefaults` (if any).
+     * Centralized so every cache-miss branch of `getOrCreate` produces a
+     * session whose per-call overlay will merge on top of the same
+     * defaults — clients cannot accidentally stray from the server's
+     * pinned sampling knobs by picking a cold-replay path.
+     */
+    private newSession;
     /**
      * Number of requests currently WAITING to acquire the per-model
      * execution mutex. Does NOT include the one actively running inside
      * `fn`. Primarily for tests and diagnostics.
      */
     get queueDepth(): number;
+    /**
+     * Configured waiter cap for this model's execution mutex, or `undefined`
+     * when unbounded. Paired with {@link queueDepth} so a readiness probe can
+     * tell "3 waiters, unbounded" (fine) from "3 waiters, cap of 3" (the next
+     * request gets a 429) without reaching into private state.
+     */
+    get queueDepthLimit(): number | undefined;
+    /**
+     * Current sampling defaults applied to every new `ChatSession` this
+     * registry allocates. Exposed primarily for tests and diagnostics.
+     */
+    get defaultSamplingConfig(): ChatConfig | undefined;
+    get outputTokenLimit(): number | undefined;
+    /**
+     * Replace the sampling defaults forwarded into every future
+     * `ChatSession` this registry allocates. Called by `ModelRegistry`
+     * on a `register(name, model, { samplingDefaults })` refresh so a
+     * fresh registration's defaults immediately apply to the next
+     * cache-miss cold-start. Sessions already cached at call time keep
+     * the defaults they were constructed with — they settle naturally
+     * through the single-warm cache rotation.
+     */
+    setSamplingDefaults(defaults: ChatConfig | undefined): void;
+    setMaxOutputTokens(limit: number | undefined): void;
     /** Number of sessions currently cached. Primarily for tests and diagnostics. Always 0 or 1. */
     get size(): number;
     /**
@@ -194,30 +312,164 @@ export declare class SessionRegistry {
      * Always returns a `SessionLookupResult` and always leaves the cache
      * empty after return (single-warm invariant).
      *
-     * On a null id, missing key, expired entry, or prefix-state
-     * mismatch: clear and return `{ session: new ChatSession(model), hit: false }`.
-     * The caller primes / cold-replays from the `ResponseStore` and
-     * re-adopts after the turn commits.
+     * Lookup proceeds in two tiers:
+     *
+     *   1. **Tier 1 — `previousResponseId`.** The existing hot path:
+     *      exact id match on a live, non-expired entry whose stored
+     *      `instructions` are byte-equal to `requestedInstructions`. On
+     *      a match the entry is leased out (single-use: removed from the
+     *      map so a concurrent second request cannot share the live
+     *      `ChatSession`). On a miss — unknown id, expired, or
+     *      instructions drift — the method falls through to a FRESH
+     *      session regardless of whether tier 2 would have hit.
      *
-     * On a hit: the entry is removed and its live session is returned
-     * alongside `hit: true`. Overlapping requests against the same
-     * `previous_response_id` cannot share the same live `ChatSession` —
-     * the first wins, the second misses and cold-replays.
+     *      `previousResponseId` wins unconditionally when supplied. The
+     *      two keys could legitimately identify different conversation
+     *      branches (e.g. a client fork where one arm chose the prev-id
+     *      path and the other arm chose to set `prompt_cache_key`
+     *      without one), so routing the prev-id branch through tier 2
+     *      on miss risks splicing the wrong warm state into the wrong
+     *      chain. Cold-replay is the safe default.
      *
-     * `requestedInstructions` is the caller's prefix/system state
-     * (OpenAI `instructions`, Anthropic `system`, or `null`); byte-for-
-     * byte mismatch against the cached entry forces cold replay so
-     * the new prefix is re-primed.
+     *   2. **Tier 2 — `promptCacheKey`.** Only runs when
+     *      `previousResponseId` is `null`. Stateless agent clients
+     *      (pi-mono, Aider, Codex CLI, Continue, etc.) never use
+     *      `previous_response_id` — they own the conversation history
+     *      client-side and resend the full transcript on every turn —
+     *      so the only way to reuse a warm session across those turns
+     *      is to key on the client-supplied `prompt_cache_key`. Scans
+     *      for any live, non-expired entry whose stored
+     *      `promptCacheKey` is non-null AND byte-equal to the caller's
+     *      `promptCacheKey` AND whose stored `instructions` are byte-
+     *      equal. Empty string is treated as a distinct key from
+     *      `null` — an opt-out sentinel from a client that forgot to
+     *      thread the key must NOT collide with another client that
+     *      did set it to empty. On a match the entry is leased out
+     *      (same single-use semantics as tier 1). On a miss, fall
+     *      through to a fresh session.
      *
      * The `hit` flag drives the `X-Session-Cache` observability header
      * emitted by both `/v1/responses` and `/v1/messages`: when the caller
      * supplied a `previous_response_id`, `hit === true` yields `hit` and
      * `hit === false` yields `cold_replay` (the endpoint then rebuilds
      * from the `ResponseStore` on a fresh session). Requests with no
-     * `previous_response_id` (or the stateless `/v1/messages` endpoint,
-     * which always passes `null`) yield `fresh` regardless of this flag.
+     * `previous_response_id` yield either `fresh` (tier-2 miss) or
+     * `prefix_hit` (tier-2 hit — only classified as such once the
+     * native `cachedTokens > 0` confirms the prefix-cache machinery
+     * actually reused the cached tokens).
+     */
+    getOrCreate(previousResponseId: string | null, requestedInstructions: string | null, promptCacheKey?: string | null): SessionLookupResult;
+    /**
+     * Allocate a fresh `ChatSession` bound to this registry's model
+     * without touching the warm slot. Intended for the `/v1/messages`
+     * endpoint when the underlying model has a block-paged KV cache
+     * active: the native cache already reuses SYS blocks across requests
+     * via content-addressing in `BlockAllocator`'s prefix-hash table, so
+     * the JS-side warm slot in
+     * {@link SessionRegistry.getOrCreateWarmAny} is redundant.
+     *
+     * Crucially, this call is purely additive — it does **NOT** clear,
+     * read, or evict the warm slot. Two parallel `/v1/messages` requests
+     * sharing a system prompt both call `createFreshSession` and both
+     * get distinct sessions; the native cache transparently refcounts
+     * the shared SYS blocks across them. This is the routing decision
+     * the long block comment in `packages/server/src/endpoints/messages.ts`
+     * documents: paged → fresh session, non-paged → warm-any lookup.
+     *
+     * The returned session is pre-seeded with the operator-configured
+     * `samplingDefaults` (matching every other cache-miss branch) so a
+     * client that picks the paged path does not silently stray from the
+     * server's pinned sampling knobs.
+     *
+     * Returned with `hit: false` to keep the result shape uniform with
+     * {@link SessionRegistry.getOrCreate} and
+     * {@link SessionRegistry.getOrCreateWarmAny}; callers that care
+     * about the cache header semantics should observe
+     * `result.cachedTokens` from the dispatch instead — that's the
+     * authoritative signal for whether the native engine recovered any
+     * prefix on this turn (paged or otherwise).
      */
-    getOrCreate(previousResponseId: string | null, requestedInstructions: string | null): SessionLookupResult;
+    createFreshSession(): SessionLookupResult;
+    /**
+     * @deprecated **Redundant on `/v1/messages` for paged-active models.**
+     * There is no call site for paged-active full-attention models (Qwen3 +
+     * LFM2 + Gemma4 today): the native block-paged KV adapter (`PagedKVCacheAdapter` +
+     * `BlockAllocator` + `LayerKVPool`) recovers a turn's prefix from
+     * refcounted KV blocks keyed by token-prefix hash, so the JS-side
+     * single-warm slot this method walks is redundant — the native
+     * cache picks up the same cross-turn reuse without the
+     * byte-equal-`instructions` gate, and additionally supports
+     * cross-conversation prefix sharing the warm slot cannot.
+     *
+     * The `/v1/messages` endpoint now branches at request time on
+     * {@link SessionCapableModel.hasBlockPagedCache}: paged-active models
+     * call {@link SessionRegistry.createFreshSession} per request and
+     * never touch the warm slot; non-paged models (Qwen3.5 dense + MoE —
+     * default-OFF pending a perf decision; the `QianfanOCRModel` VLM —
+     * no adapter wired) still call this method because the JS-side warm
+     * slot is the ONLY cross-conversation reuse mechanism available to
+     * them. Removing this method would silently disable cross-turn reuse
+     * on every non-paged model, so it stays load-bearing until ALL
+     * session-capable models have paged enabled by default. Treat
+     * `@deprecated` as an intent signal that paged-active callers should
+     * use `createFreshSession` instead.
+     *
+     * Third lookup mode — for STATELESS full-history endpoints that have
+     * no `previous_response_id` to thread and do not propagate
+     * `prompt_cache_key` back to the server. The Anthropic
+     * `/v1/messages` endpoint is the canonical caller: clients (e.g.
+     * Claude Code) POST the entire conversation each turn, so the only
+     * remaining signal that a turn N continues turn N-1's prefix is the
+     * registry's own warm slot.
+     *
+     * Behaviour: walk the registry's at-most-one warm entry. If it is
+     * non-expired AND its stored `instructions` are byte-equal to
+     * `requestedInstructions`, lease it out (single-use — `entries.clear()`
+     * before return, mirroring the tier-1 / tier-2 lease-on-hit
+     * semantics). Otherwise clear the map and return a fresh session.
+     *
+     * Crucially, this lookup IGNORES `entry.promptCacheKey` and ignores
+     * the entry's prior `previousResponseId` keying — any warm slot is
+     * fair game for `/v1/messages` reuse. The byte-equal `instructions`
+     * compare is the SOLE correctness gate: a system prompt change
+     * forces cold replay so the new prefix state is re-primed instead
+     * of silently reusing a stale warmed prompt.
+     *
+     * **Adoption sentinel.** `/v1/messages` adopts back under the literal
+     * sentinel id `'__msg_warm__'`. That sentinel will never appear as a
+     * `previous_response_id` on a `/v1/responses` request — the
+     * Anthropic Messages API does not produce a `previous_response_id`
+     * value clients could echo back, and the OpenAI side mints fresh
+     * `resp_*` ids — so cross-endpoint capture via tier-1 is impossible
+     * by construction. The two endpoints still SHARE the single warm
+     * slot under the registry's single-warm invariant: a
+     * `/v1/messages` turn that follows a `/v1/responses` turn can evict
+     * (and vice versa). That is the explicit trade-off of holding at
+     * most one warm entry per model.
+     *
+     * **Trust model.** Multi-tenant isolation on this endpoint requires
+     * fronting the server with an auth proxy that scopes warm-slot
+     * visibility per tenant — same trust boundary documented at the top
+     * of this file for the tier-2 `prompt_cache_key` path. The single-
+     * warm invariant plus `withExclusive`'s per-model serialization make
+     * the lookup safe under SINGLE-tenant assumptions: no two requests
+     * race the slot, and there is at most one slot to lease.
+     *
+     * **Caller contract on miss.** If `instructions` drifts between
+     * turns (system prompt changed) this returns `hit: false` and a
+     * fresh session — and the caller MUST then run a full
+     * `session.reset()` before priming history, NOT the JS-only
+     * `resetPreservingNativeCacheForWarmReuse` path. A fresh JS session
+     * does NOT imply a fresh native cache (the underlying
+     * `SessionCapableModel` is shared and its native
+     * `cached_token_history` persists across requests), so skipping the
+     * native wipe on a miss would let the next `chatSessionStart` reuse
+     * an unrelated previous request's prefix — the cross-request
+     * cache-affinity side channel that the long block comment in
+     * `responses.ts` (around the `runSessionNonStreaming` /
+     * `runSessionStreaming` branches) describes.
+     */
+    getOrCreateWarmAny(requestedInstructions: string | null): SessionLookupResult;
     /**
      * Insert a session under a newly allocated response id. Clears the
      * map before inserting to keep the single-warm invariant explicit
@@ -226,8 +478,17 @@ export declare class SessionRegistry {
      * `instructions` is the prefix/system state used for this turn;
      * stored on the entry and compared on the next `getOrCreate` to
      * detect prefix changes that must force a cold replay.
+     *
+     * `promptCacheKey` is the client-supplied conversation-chain key
+     * that enables the registry's tier-2 lookup for stateless agent
+     * turns that do not carry a `previous_response_id`. `null` /
+     * `undefined` means "no key supplied" — stored verbatim so a
+     * subsequent stateless lookup that also omits the key does NOT
+     * accidentally pick up this entry (only explicit non-null
+     * key-equality on both sides can hit tier 2). See
+     * {@link SessionRegistry.getOrCreate} for the precedence rules.
      */
-    adopt(responseId: string, session: ChatSession<SessionCapableModel>, instructions: string | null): void;
+    adopt(responseId: string, session: ChatSession<SessionCapableModel>, instructions: string | null, promptCacheKey?: string | null | undefined): void;
     /**
      * Remove a session by response id. No-op if the key is not present.
      */

package/dist/session-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-registry.d.ts","sourceRoot":"","sources":["../src/session-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAErE,uDAAuD;AACvD,MAAM,WAAW,sBAAsB;IACrC,sFAAsF;IACtF,KAAK,EAAE,mBAAmB,CAAC;IAC3B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAM/C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,WAAW,CAAC,mBAAmB,CAAC,CAAC;IAC1C,GAAG,EAAE,OAAO,CAAC;CACd;AAqBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,WAAW,CAAK;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAChE;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoC;IAChE;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,CAAmC;gBAEvC,IAAI,EAAE,sBAAsB;IAMxC;;;;OAIG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,+FAA+F;IAC/F,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,EAAE,qBAAqB,EAAE,MAAM,GAAG,IAAI,GAAG,mBAAmB;IAiCzG;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,mBAAmB,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IASvG;;OAEG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAI9B;;;;OAIG;IACH,KAAK,IAAI,IAAI;IASb,2DAA2D;IAC3D,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA8BlD;;;;;;;;;;OAUG;YACW,aAAa;CAiD5B"}
+{"version":3,"file":"session-registry.d.ts","sourceRoot":"","sources":["../src/session-registry.ts"],"names":[],"mappings":"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"}