cartethyia 2.7.8 → 2.8.0

package/src/providers/integrations/freepi/freepi-realm.ts

@@ -0,0 +1,35 @@
+// Free-pi realm constants.
+//
+// A single deployment with no regional variants: the backend base URL is the
+// same for everyone (FREEPI_BASE_URL defaults to https://api.freepi.ai). The
+// chat wire is OpenAI-completions (`/v1/chat/completions`), and the credential
+// is a JWT issued by the backend (device flow or guest), sent as
+// `Authorization: Bearer <jwt>`.
+
+/** Default backend base URL, matching FREEPI_BASE_URL. */
+export const FREEPI_BASE_URL = "https://api.freepi.ai";
+
+/** Chat completions path, relative to the base URL (OpenAI-completions). */
+export const FREEPI_CHAT_PATH = "/v1/chat/completions";
+
+/** Ad fetch/impression paths, relative to the base URL. */
+export const FREEPI_AD_NEXT_PATH = "/ads/next";
+export const FREEPI_AD_IMPRESSION_PATH = "/ads/impression";
+
+/** Client version the gateway reports via `x-client-version`. */
+export const FREEPI_CLI_VERSION = "0.6.14";
+
+/** Consent version shipped in 0.6.14. */
+export const FREEPI_CONSENT_VERSION = "4";
+
+/** Provider id used by the registry. */
+export const FREEPI_PROVIDER_ID = "freepi";
+
+/** Static roster fallback; the live `/client-version` catalog replaces it. */
+export const FREEPI_DEFAULT_MODEL = "deepseek/deepseek-v4-flash";
+
+/** Context window the provider reports for every model (the client hardcodes 200k). */
+export const FREEPI_CONTEXT_WINDOW = 200_000;
+
+/** Maximum output tokens the client requests (hardcoded in the bundle). */
+export const FREEPI_MAX_OUTPUT_TOKENS = 8192;

package/src/providers/integrations/freepi/freepi.ts

@@ -0,0 +1,292 @@
+// Free-pi adapter.
+//
+// OpenAI-completions wire with a JWT bearer. The model catalog is
+// server-driven (`GET /client-version`); dispatch posts to
+// `/v1/chat/completions` and translates the OpenAI-style SSE stream into
+// canonical events.
+
+import { randomUUID } from "node:crypto";
+import type {
+  CanonicalEvent,
+  CanonicalRequest,
+  CanonicalMessage,
+  CanonicalStopReason,
+} from "../../../protocol/canonical-model";
+import { GatewayError } from "../../../protocol/gateway-error";
+import {
+  assertWireFamily,
+  readCredentialSecret,
+  type ProviderAdapter,
+  type ProviderDispatchContext,
+  type ProviderDispatchTarget,
+  type ProviderId,
+} from "../../provider-contracts";
+import { mapUpstreamHttpError } from "../../../transport/failure-policy";
+import { abortGatewayError, createUpstreamDeadlineLifecycle } from "../../operations/upstream-deadline";
+import { resolvePromptCacheKey } from "../../operations/session-resolution";
+import { usageFromProvider } from "../../provider-usage";
+import { buildFreepiChatBody, parseFreepiSse, throwFreepiUpstreamError } from "./freepi-protocol";
+import { buildFreepiHeaders } from "./freepi-headers";
+import {
+  FREEPI_AD_IMPRESSION_PATH,
+  FREEPI_AD_NEXT_PATH,
+  FREEPI_BASE_URL,
+  FREEPI_CHAT_PATH,
+  FREEPI_PROVIDER_ID,
+} from "./freepi-realm";
+
+const STOP_REASONS: Readonly<Record<string, CanonicalStopReason>> = {
+  stop: "stop",
+  length: "length",
+  tool_calls: "tool_use",
+  function_call: "tool_use",
+};
+
+interface FreepiAdapterOptions {
+  readonly providerId?: string;
+  readonly fetch?: typeof fetch;
+}
+
+export class FreepiAdapter implements ProviderAdapter {
+  readonly provider_id: ProviderId;
+  private readonly fetchFn: typeof fetch;
+  /**
+   * One stable ad-registered session id per account credential, so repeated
+   * chats reuse a session the upstream knows has shown ads. The session must
+   * exist for the chat wire: without it the server answers `ads_required`
+   * ("Ads aren't showing for this account, so free completions are paused").
+   */
+  #sessionByCredential = new Map<string, string>();
+
+  constructor(options: FreepiAdapterOptions = {}) {
+    this.provider_id = (options.providerId ?? FREEPI_PROVIDER_ID) as ProviderId;
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+  }
+
+  /**
+   * Ensures a session id exists for this credential and that the session has
+   * registered at least one ad impression (banner + inline). The upstream
+   * refuses the chat wire with `ads_required` until a session has shown ads,
+   * so the first call per credential pays the two ad-registration requests.
+   *
+   * Returns the session id to send as `x-session-id`. Falls back to a fresh
+   * random id when registration fails — a broken ad surface must not block
+   * chat entirely, and the error is caught upstream anyway.
+   */
+  async #ensureSession(secret: string, outboundFetch: typeof fetch): Promise<string> {
+    const existing = this.#sessionByCredential.get(secret);
+    if (existing !== undefined) return existing;
+    const sessionId = randomUUID();
+    try {
+      for (const slot of ["banner", "inline"] as const) {
+        const next = await outboundFetch(new URL(`${FREEPI_AD_NEXT_PATH}?slot=${slot}`, FREEPI_BASE_URL), {
+          method: "GET",
+          headers: buildFreepiHeaders(secret, false, sessionId),
+          signal: AbortSignal.timeout(15_000),
+        });
+        if (!next.ok || next.status === 204) continue;
+        const ad = (await next.json()) as Record<string, unknown>;
+        const adId = ad["ad_id"];
+        const clickToken = ad["click_token"];
+        if (typeof adId !== "string" || typeof clickToken !== "string") continue;
+        await outboundFetch(new URL(FREEPI_AD_IMPRESSION_PATH, FREEPI_BASE_URL), {
+          method: "POST",
+          headers: buildFreepiHeaders(secret, false, sessionId),
+          body: JSON.stringify({ ad_id: adId, click_token: clickToken, imp_fired: true }),
+          signal: AbortSignal.timeout(15_000),
+        });
+      }
+    } catch {
+      // The ad surface is best-effort; chat may still work or fail upstream.
+    }
+    this.#sessionByCredential.set(secret, sessionId);
+    return sessionId;
+  }
+
+  async *dispatch(
+    request: CanonicalRequest,
+    candidate: ProviderDispatchTarget,
+    context: ProviderDispatchContext,
+  ): AsyncIterable<CanonicalEvent> {
+    if (candidate.wire_family !== "chat") {
+      assertWireFamily(candidate, "chat", "freepi");
+    }
+    const secret = readCredentialSecret(context.credential, "Free-pi credential is required");
+    const modelId = candidate.model_id || request.model;
+    const lifecycle = createUpstreamDeadlineLifecycle(context);
+    const outboundFetch =
+      (context.outbound_fetch as unknown as typeof fetch | undefined) ?? this.fetchFn;
+
+    const body = buildFreepiChatBody(modelId, request, candidate.output_limit ?? undefined);
+
+    const sessionKey = resolvePromptCacheKey(request, context);
+    const cacheSessionKey = sessionKey === undefined ? undefined : `${modelId}:${sessionKey}`;
+
+    const sessionId = await this.#ensureSession(secret, outboundFetch);
+    const headers = buildFreepiHeaders(secret, true, sessionId);
+    const url = `${FREEPI_BASE_URL}${FREEPI_CHAT_PATH}`;
+
+    try {
+      const response = await outboundFetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: lifecycle.signal,
+      });
+      if (!response.ok) throw await mapUpstreamHttpError(response, this.provider_id);
+      if (!response.body) {
+        throw new GatewayError("platform_unavailable", 502, "Free-pi returned empty body (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
+      }
+      lifecycle.release();
+      yield* this.#events(
+        response.body as ReadableStream<Uint8Array>,
+        lifecycle.signal,
+        request.model,
+        cacheSessionKey,
+        request.messages,
+      );
+    } catch (err: unknown) {
+      const abortError = abortGatewayError(lifecycle, err, context.abort_signal);
+      if (abortError) throw abortError;
+      throw err;
+    } finally {
+      lifecycle.release();
+    }
+  }
+
+  async *#events(
+    body: ReadableStream<Uint8Array>,
+    _signal: AbortSignal,
+    requestModel: string,
+    sessionId?: string,
+    _messages?: readonly CanonicalMessage[],
+  ): AsyncIterable<CanonicalEvent> {
+    let seq = 1;
+    yield { type: "response_start", sequence_number: seq++, model: requestModel } as CanonicalEvent;
+    let stopReason: CanonicalStopReason = "stop";
+    let usage: Record<string, unknown> | undefined;
+    const toolCallIds = new Map<string, string>();
+    const announced = new Set<string>();
+
+    for await (const frame of parseFreepiSse(body)) {
+      if (frame.event === "done") {
+        const data = frame.data as { finish_reason?: unknown };
+        if (typeof data.finish_reason === "string") {
+          stopReason = STOP_REASONS[data.finish_reason] ?? "stop";
+        }
+        continue;
+      }
+      if (typeof frame.data !== "object" || frame.data === null) continue;
+      const record = frame.data as Record<string, unknown>;
+
+      // Upstream error payloads can be HTTP 200 `{"error":{...}}`.
+      if (record["error"] !== undefined && typeof record["error"] === "object") {
+        const nested = record["error"] as Record<string, unknown>;
+        throwFreepiUpstreamError(nested["code"], nested["message"]);
+      }
+      if (record["code"] !== undefined) {
+        throwFreepiUpstreamError(record["code"], record["message"]);
+      }
+
+      const choices = Array.isArray(record["choices"]) ? (record["choices"] as Record<string, unknown>[]) : [];
+      const choice = choices[0];
+      if (!choice) continue;
+      const delta = choice["delta"] as Record<string, unknown> | undefined;
+      if (!delta) continue;
+
+      const text = delta["content"];
+      if (typeof text === "string" && text.length > 0) {
+        yield {
+          type: "content_delta",
+          sequence_number: seq++,
+          content: { kind: "text", text },
+        } as CanonicalEvent;
+      }
+      const reasoning = delta["reasoning_content"];
+      if (typeof reasoning === "string" && reasoning.length > 0) {
+        yield {
+          type: "content_delta",
+          sequence_number: seq++,
+          content: { kind: "reasoning", payload: null, summary: reasoning },
+        } as CanonicalEvent;
+      }
+      yield* this.#toolCallDeltas(delta["tool_calls"], announced, toolCallIds, () => seq++);
+      if (typeof choice["finish_reason"] === "string" && choice["finish_reason"] !== null) {
+        stopReason = STOP_REASONS[String(choice["finish_reason"])] ?? "stop";
+      }
+      const u = record["usage"];
+      if (typeof u === "object" && u !== null) usage = u as Record<string, unknown>;
+    }
+
+    const assessed = usage === undefined ? undefined : usageFromProvider(usage);
+    if (assessed !== undefined) {
+      yield { type: "usage", sequence_number: seq++, usage: assessed } as unknown as CanonicalEvent;
+    }
+    yield {
+      type: "terminal",
+      sequence_number: seq,
+      state: "complete",
+      stop_reason: stopReason,
+      ...(assessed === undefined ? {} : { usage: assessed }),
+      ...(sessionId !== undefined ? { prompt_cache_key: sessionId } : {}),
+    } as unknown as CanonicalEvent;
+  }
+
+  /**
+   * Emits canonical tool-call deltas from one OpenAI `tool_calls` array.
+   *
+   * The upstream spreads one call over many frames: the first carries id and
+   * name, the middle ones carry `arguments` as successive JSON fragments with
+   * an empty id, and the last repeats the id with no arguments. Grouping by
+   * `index` ties them together — the id is absent exactly when the arguments
+   * are present, so keying on id would drop every fragment.
+   */
+  async *#toolCallDeltas(
+    raw: unknown,
+    announced: Set<string>,
+    toolCallIds: Map<string, string>,
+    nextSeq: () => number,
+  ): AsyncIterable<CanonicalEvent> {
+    if (!Array.isArray(raw)) return;
+    for (const entry of raw) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const call = entry as Record<string, unknown>;
+      const fn = call["function"];
+      const fnRecord = typeof fn === "object" && fn !== null ? (fn as Record<string, unknown>) : undefined;
+      const name = typeof fnRecord?.["name"] === "string" ? (fnRecord["name"] as string) : undefined;
+      const args = typeof fnRecord?.["arguments"] === "string" ? (fnRecord["arguments"] as string) : "";
+      const declaredId = typeof call["id"] === "string" ? call["id"] : "";
+      const index = typeof call["index"] === "number" ? call["index"] : 0;
+      const slot = `idx:${index}`;
+
+      if (declaredId.length > 0) {
+        toolCallIds.set(slot, declaredId);
+        if (announced.has(declaredId)) continue;
+        announced.add(declaredId);
+        yield {
+          type: "tool_call_delta",
+          sequence_number: nextSeq(),
+          call_id: declaredId,
+          name: name ?? "",
+          arguments_delta: "",
+        } as CanonicalEvent;
+        if (args.length === 0) continue;
+      }
+
+      if (args.length === 0) continue;
+      const id = toolCallIds.get(slot);
+      if (id === undefined) continue;
+      yield {
+        type: "tool_call_delta",
+        sequence_number: nextSeq(),
+        call_id: id,
+        arguments_delta: args,
+      } as CanonicalEvent;
+    }
+  }
+}
+
+/** Adapter for the international free-pi deployment. */
+export function createFreepiAdapter(options: FreepiAdapterOptions = {}): ProviderAdapter {
+  return new FreepiAdapter({ ...options, providerId: FREEPI_PROVIDER_ID });
+}

package/src/providers/integrations/gemini.ts

@@ -241,7 +241,7 @@ class GeminiAdapter implements ProviderAdapter {
         let seq = 1;
         yield { type: "response_start", sequence_number: seq++, model: request.model } as CanonicalEvent;
         if (output.thought) {
-          yield { type: "content_delta", sequence_number: seq++, content: { kind: "reasoning", payload: null, summary: output.thought } } as CanonicalEvent;
+          yield { type: "content_delta", sequence_number: seq++, content: { kind: "reasoning", payload: null, summary: output.thought, ...(output.thoughtSignature ? { signature: output.thoughtSignature } : {}) } } as CanonicalEvent;
         }
         if (output.text) {
           yield { type: "content_delta", sequence_number: seq++, content: { kind: "text", text: output.text } } as CanonicalEvent;
@@ -277,7 +277,7 @@ class GeminiAdapter implements ProviderAdapter {
         const { candidate: cand, parts } = geminiCandidate(parsed);
         const output = responseParts(parts);
         if (output.thought) {
-          yield { type: "content_delta", sequence_number: seq++, content: { kind: "reasoning", payload: null, summary: output.thought } } as CanonicalEvent;
+          yield { type: "content_delta", sequence_number: seq++, content: { kind: "reasoning", payload: null, summary: output.thought, ...(output.thoughtSignature ? { signature: output.thoughtSignature } : {}) } } as CanonicalEvent;
         }
         if (output.text) {
           yield { type: "content_delta", sequence_number: seq++, content: { kind: "text", text: output.text } } as CanonicalEvent;

package/src/providers/integrations/grok/grok-oauth.ts

@@ -1,13 +1,14 @@
 /** xAI Grok Build device-code OAuth client. */
-import { devicePollBackoff, nonEmptyTrimmedString, parseDeviceAuthStart, postFormTokenRequest, readJsonResponse } from "../../authentication/oauth-flow-store";
+import { devicePollBackoff, nonEmptyTrimmedString, parseDeviceAuthStart, postFormTokenRequest, readJsonResponse, record } from "../../authentication/oauth-flow-store";
 import type {
   OAuthDeviceFlowContext,
   OAuthDevicePollResult,
   OAuthDeviceStartResult,
+  OAuthExchangeResult,
 } from "../../authentication/oauth-flow-store";
 import type { OAuthTokenRefreshResult } from "../../authentication/oauth-refresh-service";
 import { OAuthDeviceFlow } from "../../authentication/oauth-device-flow";
-import type { FetchLike } from "../../authentication/oauth-client";
+import type { FetchLike, NormalizedTokenResponse } from "../../authentication/oauth-client";
 import { XAI_AUTH_SERVER } from "../xai/xai-oauth";
 
 /**
@@ -178,56 +179,58 @@ export class GrokOAuthClient extends OAuthDeviceFlow {
   }
 
   override async pollDeviceAuth(deviceAuthId: string, _context?: OAuthDeviceFlowContext): Promise<OAuthDevicePollResult> {
-    const body = new URLSearchParams({
-      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-      device_code: deviceAuthId,
-      client_id: GROK_CLIENT_ID,
-    });
-    const response = await this.fetchFn(GROK_TOKEN_URL, {
-      method: "POST",
-      headers: authHeaders(),
-      body,
+    return this.pollGenericDeviceAuth(deviceAuthId, {
+      tokenUrl: GROK_TOKEN_URL,
+      deviceAuthUrl: GROK_DEVICE_URL,
+      clientId: GROK_CLIENT_ID,
+      formHeaders: authHeaders(),
     });
-    const raw = await response.text();
-    let payload: TokenPayload;
-    try {
-      payload = JSON.parse(raw) as TokenPayload;
-    } catch {
-      return { status: "failed", reason: "grok token endpoint returned invalid JSON" };
-    }
-    const error = nonEmptyTrimmedString(payload.error);
-    const verdict = devicePollBackoff(error, payload.interval);
-    if (verdict !== undefined) return verdict;
-    if (!response.ok) {
-      return { status: "failed", reason: nonEmptyTrimmedString(payload.error_description) ?? error ?? `token polling failed (${response.status})` };
-    }
+  }
+
+  protected override unparsablePollReason(_status: number): string {
+    return "grok token endpoint returned invalid JSON";
+  }
+
+  protected override preVerdict(payload: unknown): OAuthDevicePollResult | undefined {
+    const root = record(payload) ?? {};
+    // Grok votes on the `error` field before the status: a 200 body can still
+    // state the poll state, and a pending/slow_down answer is honored wherever
+    // it appears on the wire.
+    return devicePollBackoff(nonEmptyTrimmedString(root.error), root.interval);
+  }
+
+  protected override pollFailureReason(
+    status: number,
+    errorKey: string | undefined,
+    errorDescription: string | undefined,
+  ): string {
+    // Grok's wire prefers the human-readable description over the error code,
+    // and falls back to the generic phrasing only when both are absent.
+    return nonEmptyTrimmedString(errorDescription) ?? nonEmptyTrimmedString(errorKey) ?? `token polling failed (${status})`;
+  }
+
+  protected override missingTokenReason(errorKey: string | undefined, errorDescription: string | undefined): string {
     // A 2xx is not by itself a completed authorization: the endpoint can answer
     // 200 with an `error` field and no token. Returning `failed` rather than
     // letting the shared parser throw keeps the verdict inside the poll
     // contract — the dashboard's poll error path stops polling but shows no
     // reason, so a throw would look like a spinner that never ends.
-    if (nonEmptyTrimmedString(payload.access_token) === undefined) {
-      return {
-        status: "failed",
-        reason:
-          nonEmptyTrimmedString(payload.error_description) ??
-          error ??
-          "grok token response omitted access_token",
-      };
-    }
-    const result = this.parseTokenResponse(payload);
-    const identity = await fetchGrokIdentity(result.access, this.fetchFn);
+    return nonEmptyTrimmedString(errorDescription) ?? nonEmptyTrimmedString(errorKey) ?? "grok token response omitted access_token";
+  }
+
+  protected override async afterDeviceTokenExchange(
+    _payload: unknown,
+    normalized: NormalizedTokenResponse,
+  ): Promise<OAuthExchangeResult> {
+    const identity = await fetchGrokIdentity(normalized.access, this.fetchFn);
     const authState = grokAuthState(identity);
-    return {
-      status: "complete",
-      result: this.toExchangeResult({
-        ...result,
-        ...(identity.label === undefined ? {} : { accountLabel: identity.label }),
-        // Omitted when the proxy reported nothing, which leaves any stored
-        // state alone rather than blanking it.
-        ...(authState === undefined ? {} : { auth_state: authState }),
-      }),
-    };
+    return this.toExchangeResult({
+      ...normalized,
+      ...(identity.label === undefined ? {} : { accountLabel: identity.label }),
+      // Omitted when the proxy reported nothing, which leaves any stored
+      // state alone rather than blanking it.
+      ...(authState === undefined ? {} : { auth_state: authState }),
+    });
   }
 
   override async refresh(refreshToken: string, signal?: AbortSignal): Promise<OAuthTokenRefreshResult> {

package/src/providers/integrations/grok/grok-ratelimit-store.ts

@@ -12,6 +12,7 @@
 // Keyed by account id: two Grok accounts carry different buckets, and a reading
 // filed against the wrong one is worse than no reading at all.
 
+import { TtlCache } from "../../../persistence/ttl-cache";
 import type { ProviderQuotaWindow } from "../../quota/quota-contracts";
 import { grokHeaderRequestsWindow, grokHeaderWindow, type GrokRateLimitReading } from "./grok-ratelimit";
 
@@ -27,39 +28,31 @@ const SNAPSHOT_TTL_MS = 5 * 60 * 1000;
 
 interface Snapshot {
   readonly windows: readonly ProviderQuotaWindow[];
-  readonly capturedAt: number;
 }
 
-const snapshots = new Map<string, Snapshot>();
+// Bounded FIFO cache keyed by account id; the TTL and `maxEntries` cap are
+// enforced by the cache itself (oldest-first eviction past 4096 entries).
+const snapshots = new TtlCache<Snapshot>({
+  ttlMs: SNAPSHOT_TTL_MS,
+  maxEntries: 4096,
+});
 
 /** Files a reading captured from a real dispatch against one account. */
 export function rememberGrokRateLimit(
   accountId: string,
   reading: GrokRateLimitReading,
-  now = Date.now(),
 ): void {
   const windows = [grokHeaderWindow(reading), grokHeaderRequestsWindow(reading)].filter(
     (value): value is ProviderQuotaWindow => value !== null,
   );
   if (windows.length === 0) return;
-  snapshots.set(accountId, { windows, capturedAt: now });
-  if (snapshots.size > 4096) {
-    // Bounded: an unbounded map keyed by account is a leak dressed as a cache.
-    for (const [key, value] of snapshots) {
-      if (now - value.capturedAt > SNAPSHOT_TTL_MS) snapshots.delete(key);
-    }
-  }
+  snapshots.set(accountId, { windows });
 }
 
 /** The stored window for one account, or `null` when none is fresh enough. */
-export function storedGrokRateLimit(accountId: string, now = Date.now()): readonly ProviderQuotaWindow[] | null {
+export function storedGrokRateLimit(accountId: string): readonly ProviderQuotaWindow[] | null {
   const snapshot = snapshots.get(accountId);
-  if (!snapshot) return null;
-  if (now - snapshot.capturedAt > SNAPSHOT_TTL_MS) {
-    snapshots.delete(accountId);
-    return null;
-  }
-  return snapshot.windows;
+  return snapshot?.windows ?? null;
 }
 
 /** Test seam. */

package/src/providers/integrations/grok/grok-turn-index.ts

@@ -13,19 +13,25 @@
  */
 
 import type { CanonicalRequest } from "../../../protocol/canonical-model";
+import { TtlCache } from "../../../persistence/ttl-cache";
 
 /** Idle window after which a session's remembered index is discarded. */
 const SESSION_TTL_MS = 30 * 60_000;
 
-/** Bound on remembered sessions; oldest insertion is evicted past this. */
+/** Bound on remembered sessions; least-recently-used is evicted past this. */
 const MAX_SESSIONS = 5_000;
 
 interface TurnEntry {
   readonly turn: number;
-  lastUsedAt: number;
 }
 
-const turns = new Map<string, TurnEntry>();
+// Bounded, LRU-ordered: a session re-inserts on every use so the newest
+// session is the last evicted, exactly as the previous delete-then-set Map.
+const turns = new TtlCache<TurnEntry>({
+  ttlMs: SESSION_TTL_MS,
+  maxEntries: MAX_SESSIONS,
+  lru: true,
+});
 const requestTurns = new WeakMap<object, number>();
 
 /** User turns in the request, floored at 1 (a turn is never index 0). */
@@ -58,25 +64,14 @@ export function resolveGrokTurnIndex(
   }
   if (sessionId === undefined || sessionId.length === 0) return fromInput;
 
-  const now = Date.now();
-  const previous = turns.get(sessionId);
-  const remembered =
-    previous !== undefined && now - previous.lastUsedAt <= SESSION_TTL_MS
-      ? previous.turn
-      : undefined;
+  const remembered = turns.get(sessionId)?.turn;
 
   // A full-history client already reports the true index; a delta-style client
   // reports 1 every time, so the stored index is advanced by one for it.
   const turn = remembered === undefined ? fromInput : Math.max(fromInput, remembered + 1);
 
   // Re-insert so the entry is newest for eviction order.
-  turns.delete(sessionId);
-  if (turns.size >= MAX_SESSIONS) {
-    const oldest = turns.keys().next();
-    if (!oldest.done) turns.delete(oldest.value);
-  }
-  turns.set(sessionId, { turn, lastUsedAt: now });
+  turns.set(sessionId, { turn });
   if (requestKey !== undefined) requestTurns.set(requestKey, turn);
   return turn;
 }
-