@bitkyc08/opencodex 2.75.0 → 2.76.0

package/src/providers/zed.ts

@@ -0,0 +1,598 @@
+import { constants, createHash, generateKeyPairSync, privateDecrypt, randomUUID } from "node:crypto";
+import { redactSecretString } from "../lib/redact";
+
+export const ZED_WEB_BASE_URL = "https://zed.dev";
+export const ZED_CLOUD_BASE_URL = "https://cloud.zed.dev";
+export const ZED_HEADERS = Object.freeze({
+  expiredToken: "x-zed-expired-token",
+  outdatedToken: "x-zed-outdated-token",
+  clientSupportsStatus: "x-zed-client-supports-status-messages",
+  clientSupportsStreamEnded: "x-zed-client-supports-stream-ended-request-completion-status",
+  clientSupportsXai: "x-zed-client-supports-x-ai",
+  systemId: "x-zed-system-id",
+});
+
+const PRIVATE_KEY_PREFIX = "zed-rsa-pkcs1:";
+const LLM_TOKEN_TTL_MS = 50 * 60 * 1000;
+const MODEL_CACHE_TTL_MS = 60 * 60 * 1000;
+const MODEL_RESPONSE_MAX_BYTES = 4 * 1024 * 1024;
+const SMALL_RESPONSE_MAX_BYTES = 64 * 1024;
+const MODEL_MAX_ROWS = 2_000;
+
+export interface ZedCredentials {
+  userId: string;
+  accessToken: string;
+  systemId?: string;
+}
+
+export interface ZedNativeAuthData {
+  authUrl: string;
+  privateKeyVerifier: string;
+  nativeAppPort: number;
+  systemId: string;
+  publicKey: string;
+}
+
+export interface ZedCallbackPayload {
+  userId: string;
+  encryptedAccessToken: string;
+}
+
+export interface ZedModel {
+  id: string;
+  name: string;
+  provider?: string;
+  contextLength?: number;
+  contextLengthInMaxMode?: number;
+  maxOutputTokens?: number;
+  supportsTools: boolean;
+  supportsImages: boolean;
+  supportsThinking: boolean;
+  supportsDisablingThinking: boolean;
+  supportsFastMode: boolean;
+  supportedEffortLevels: string[];
+  isDisabled: boolean;
+}
+
+export interface ZedModelCatalog {
+  expiresAt: number;
+  models: ZedModel[];
+  rawById: Map<string, Record<string, unknown>>;
+  defaultModel?: string;
+  defaultFastModel?: string;
+  recommendedModels: string[];
+}
+
+export type ZedFetch = typeof globalThis.fetch;
+
+interface ZedRequestOptions {
+  fetchFn?: ZedFetch;
+  signal?: AbortSignal;
+  forceRefresh?: boolean;
+}
+
+interface CachedLlmToken {
+  token: string;
+  expiresAt: number;
+  organizationId: string;
+}
+
+const llmTokenCache = new Map<string, CachedLlmToken>();
+const organizationCache = new Map<string, string>();
+const modelCache = new Map<string, ZedModelCatalog>();
+const modelInflight = new Map<string, Promise<ZedModelCatalog>>();
+
+function base64Url(value: Uint8Array | string): string {
+  return Buffer.from(value).toString("base64url");
+}
+
+function decodeBase64Url(value: string): Buffer {
+  return Buffer.from(value, "base64url");
+}
+
+function normalizeBaseUrl(value: string | undefined, fallback: string): string {
+  return String(value || fallback).replace(/\/+$/, "");
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function normalizeModelId(value: unknown): string {
+  if (typeof value === "string") return value.trim();
+  if (Array.isArray(value) && typeof value[0] === "string") return value[0].trim();
+  if (value && typeof value === "object" && typeof (value as { id?: unknown }).id === "string") {
+    return String((value as { id: string }).id).trim();
+  }
+  return "";
+}
+
+function zedCacheKey(credentials: ZedCredentials): string {
+  // In-memory caches are keyed by an irreversible digest so no map key holds the raw token.
+  return createHash("sha256").update(JSON.stringify([credentials.userId, credentials.accessToken])).digest("hex");
+}
+
+function zedUrl(path: string, baseUrl = ZED_CLOUD_BASE_URL): string {
+  return `${normalizeBaseUrl(baseUrl, ZED_CLOUD_BASE_URL)}${path}`;
+}
+
+/** Build Zed's native-app URL and retain the private key only in an opaque verifier string. */
+export function createZedNativeAuthData(nativeAppPort: number, systemId = randomUUID()): ZedNativeAuthData {
+  if (!Number.isInteger(nativeAppPort) || nativeAppPort <= 0 || nativeAppPort > 65_535) {
+    throw new Error("Zed native-app callback port is invalid");
+  }
+  const { publicKey, privateKey } = generateKeyPairSync("rsa", {
+    modulusLength: 2_048,
+    publicKeyEncoding: { type: "pkcs1", format: "der" },
+    privateKeyEncoding: { type: "pkcs1", format: "pem" },
+  });
+  const url = new URL(`${ZED_WEB_BASE_URL}/native_app_signin`);
+  url.searchParams.set("native_app_port", String(nativeAppPort));
+  url.searchParams.set("native_app_public_key", base64Url(publicKey));
+  url.searchParams.set("system_id", systemId);
+  return {
+    authUrl: url.toString(),
+    privateKeyVerifier: `${PRIVATE_KEY_PREFIX}${base64Url(privateKey)}`,
+    nativeAppPort,
+    systemId,
+    publicKey: base64Url(publicKey),
+  };
+}
+
+function decodePrivateKeyVerifier(verifier: string): string {
+  if (!verifier.startsWith(PRIVATE_KEY_PREFIX)) {
+    throw new Error("Missing Zed private-key verifier; restart the login flow");
+  }
+  return decodeBase64Url(verifier.slice(PRIVATE_KEY_PREFIX.length)).toString("utf8");
+}
+
+/** Parse a native-app callback URL, query string, or JSON payload without logging its token. */
+export function parseZedCallbackPayload(input: string): ZedCallbackPayload {
+  const raw = input.trim();
+  if (!raw) throw new Error("Missing Zed callback URL");
+  let data: Record<string, unknown> = {};
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not an object");
+    data = parsed as Record<string, unknown>;
+  } catch {
+    let url: URL;
+    try {
+      url = new URL(raw);
+    } catch {
+      const query = raw.includes("?") ? raw.slice(raw.indexOf("?") + 1) : raw.replace(/^\?/, "");
+      url = new URL(`http://127.0.0.1/?${query}`);
+    }
+    url.searchParams.forEach((value, key) => { data[key] = value; });
+  }
+  const userId = stringValue(data.user_id) ?? stringValue(data.userId);
+  const encryptedAccessToken = stringValue(data.access_token)
+    ?? stringValue(data.accessToken)
+    ?? stringValue(data.token);
+  if (!userId || !encryptedAccessToken) {
+    throw new Error("Zed callback must include user_id and access_token");
+  }
+  return { userId, encryptedAccessToken };
+}
+
+/** Decrypt the callback token with OAEP-SHA256, falling back to PKCS#1 v1.5 for older Zed builds. */
+export function decryptZedAccessToken(encryptedAccessToken: string, privateKeyVerifier: string): string {
+  const encrypted = decodeBase64Url(encryptedAccessToken);
+  const privateKey = decodePrivateKeyVerifier(privateKeyVerifier);
+  let oaepError: unknown;
+  try {
+    const token = privateDecrypt(
+      { key: privateKey, padding: constants.RSA_PKCS1_OAEP_PADDING, oaepHash: "sha256" },
+      encrypted,
+    ).toString("utf8");
+    if (!token || token.includes("�")) throw new Error("decrypted token is invalid UTF-8");
+    return token;
+  } catch (error) {
+    oaepError = error;
+  }
+  try {
+    const token = privateDecrypt(
+      { key: privateKey, padding: constants.RSA_PKCS1_PADDING },
+      encrypted,
+    ).toString("utf8");
+    // PKCS#1 v1.5 unpadding is not integrity-checked. Replacement characters are a
+    // concrete signal that a wrong key or malformed ciphertext produced garbage.
+    if (!token || token.includes("�")) throw new Error("decrypted token is invalid UTF-8");
+    return token;
+  } catch {
+    const reason = oaepError instanceof Error ? oaepError.message : "unsupported ciphertext";
+    throw new Error(`Failed to decrypt Zed access token: ${reason}`);
+  }
+}
+
+export function buildZedUserAuthHeader(credentials: ZedCredentials): string {
+  if (!credentials.userId || !credentials.accessToken) throw new Error("Zed credential is incomplete");
+  return `${credentials.userId} ${credentials.accessToken}`;
+}
+
+function systemHeaders(credentials: ZedCredentials): Record<string, string> {
+  return credentials.systemId ? { [ZED_HEADERS.systemId]: credentials.systemId } : {};
+}
+
+/** Remove the account token and user id from upstream text before it can reach an error or log. */
+export function scrubZedCredentials(text: string, credentials: ZedCredentials): string {
+  let scrubbed = text;
+  for (const secret of [credentials.accessToken, credentials.userId]) {
+    const value = secret?.trim();
+    if (value) scrubbed = scrubbed.split(value).join("[redacted]");
+  }
+  return redactSecretString(scrubbed);
+}
+
+function rejectionMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function containsZedCredential(text: string, credentials: ZedCredentials): boolean {
+  return [credentials.accessToken, credentials.userId].some((secret) => {
+    const value = secret?.trim();
+    return Boolean(value) && text.includes(value!);
+  });
+}
+
+/**
+ * Rethrow a rejection from a credential-bearing Zed call without the account token or user id.
+ *
+ * The decision is made on content alone: a rejection that carries neither value is rethrown by
+ * identity, so a clean abort stays the same object. One that carries either is replaced, keeping
+ * its `name` (a DOMException stays a DOMException, so AbortError/TimeoutError still read as
+ * cancellation) and any numeric `status`. The original is not kept as `cause`, because its
+ * message is exactly what must not travel.
+ */
+export function scrubZedRejection(error: unknown, credentials: ZedCredentials): never {
+  const message = rejectionMessage(error);
+  const name = error instanceof Error ? error.name : "Error";
+  if (!containsZedCredential(message, credentials) && !containsZedCredential(name, credentials)) throw error;
+  const scrubbed = scrubZedCredentials(message, credentials);
+  const safeName = containsZedCredential(name, credentials) ? "Error" : name;
+  const replacement: Error = error instanceof DOMException
+    ? new DOMException(scrubbed, safeName)
+    : Object.assign(new Error(scrubbed), { name: safeName });
+  const status = error && typeof error === "object" ? (error as { status?: unknown }).status : undefined;
+  if (typeof status === "number") Object.assign(replacement, { status });
+  throw replacement;
+}
+
+async function responseJson(response: Response, label: string, credentials: ZedCredentials): Promise<unknown> {
+  const length = Number(response.headers.get("content-length"));
+  if (Number.isFinite(length) && length > SMALL_RESPONSE_MAX_BYTES) {
+    await response.body?.cancel().catch(() => undefined);
+    throw new Error(`${label}: response exceeded the size limit`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    if (!response.ok) throw new Error(`${label}: HTTP ${response.status}`);
+    return null;
+  }
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > SMALL_RESPONSE_MAX_BYTES) {
+        await reader.cancel().catch(() => undefined);
+        throw new Error(`${label}: response exceeded the size limit`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  let data: unknown = null;
+  if (text) {
+    try { data = JSON.parse(text) as unknown; } catch { data = { raw: text }; }
+  }
+  if (response.ok) return data;
+  const record = data && typeof data === "object" && !Array.isArray(data)
+    ? data as Record<string, unknown>
+    : undefined;
+  const nested = record?.error && typeof record.error === "object" && !Array.isArray(record.error)
+    ? record.error as Record<string, unknown>
+    : undefined;
+  const message = stringValue(record?.message) ?? stringValue(nested?.message) ?? `HTTP ${response.status}`;
+  const error = new Error(`${label}: ${scrubZedCredentials(message, credentials)}`);
+  Object.assign(error, { status: response.status });
+  throw error;
+}
+
+export async function fetchZedAuthenticatedUser(
+  credentials: ZedCredentials,
+  options: ZedRequestOptions = {},
+): Promise<Record<string, unknown>> {
+  const fetchFn = options.fetchFn ?? globalThis.fetch;
+  let value: unknown;
+  try {
+    const response = await fetchFn(zedUrl("/client/users/me"), {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: buildZedUserAuthHeader(credentials),
+        ...systemHeaders(credentials),
+      },
+      signal: options.signal,
+    });
+    value = await responseJson(response, "Zed account lookup", credentials);
+  } catch (error) {
+    scrubZedRejection(error, credentials);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Zed account lookup returned an invalid response");
+  return value as Record<string, unknown>;
+}
+
+function normalizeOrganizationId(value: unknown): string | undefined {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  if (Array.isArray(value) && typeof value[0] === "string" && value[0].trim()) return value[0].trim();
+  if (value && typeof value === "object" && typeof (value as { id?: unknown }).id === "string") {
+    return String((value as { id: string }).id).trim() || undefined;
+  }
+  return undefined;
+}
+
+export function resolveZedOrganizationId(user: Record<string, unknown>): string | undefined {
+  const explicit = normalizeOrganizationId(user.default_organization_id)
+    ?? normalizeOrganizationId(user.defaultOrganizationId)
+    ?? normalizeOrganizationId(user.organization_id)
+    ?? normalizeOrganizationId(user.organizationId)
+    ?? normalizeOrganizationId(user.default_organization);
+  if (explicit) return explicit;
+  const organizations = Array.isArray(user.organizations) ? user.organizations : [];
+  const personal = organizations.find(item => item && typeof item === "object" && (item as { is_personal?: unknown }).is_personal === true);
+  const selected = personal ?? organizations[0];
+  return selected && typeof selected === "object"
+    ? normalizeOrganizationId((selected as { id?: unknown }).id)
+    : undefined;
+}
+
+async function resolveOrganization(
+  credentials: ZedCredentials,
+  options: ZedRequestOptions,
+): Promise<string> {
+  const key = zedCacheKey(credentials);
+  const cached = organizationCache.get(key);
+  if (cached) return cached;
+  const user = await fetchZedAuthenticatedUser(credentials, options);
+  const organizationId = resolveZedOrganizationId(user);
+  if (!organizationId) throw new Error("Zed account has no organization");
+  organizationCache.set(key, organizationId);
+  return organizationId;
+}
+
+export async function fetchZedLlmToken(
+  credentials: ZedCredentials,
+  options: ZedRequestOptions = {},
+): Promise<string> {
+  const key = zedCacheKey(credentials);
+  const cached = llmTokenCache.get(key);
+  if (!options.forceRefresh && cached && cached.expiresAt > Date.now()) return cached.token;
+  const organizationId = await resolveOrganization(credentials, options);
+  const fetchFn = options.fetchFn ?? globalThis.fetch;
+  let data: unknown;
+  try {
+    const response = await fetchFn(zedUrl("/client/llm_tokens"), {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: buildZedUserAuthHeader(credentials),
+        ...systemHeaders(credentials),
+      },
+      body: JSON.stringify({ organization_id: organizationId }),
+      signal: options.signal,
+    });
+    data = await responseJson(response, "Zed LLM token exchange", credentials);
+  } catch (error) {
+    scrubZedRejection(error, credentials);
+  }
+  const record = data && typeof data === "object" && !Array.isArray(data)
+    ? data as Record<string, unknown>
+    : undefined;
+  const token = stringValue(record?.token)
+    ?? (record?.token && typeof record.token === "object" ? stringValue((record.token as { value?: unknown }).value) : undefined)
+    ?? stringValue(record?.access_token)
+    ?? stringValue(record?.llm_token)
+    ?? stringValue(record?.llmToken);
+  if (!token) throw new Error("Zed LLM token exchange returned no token");
+  llmTokenCache.set(key, { token, organizationId, expiresAt: Date.now() + LLM_TOKEN_TTL_MS });
+  return token;
+}
+
+export function shouldRefreshZedLlmToken(response: Response): boolean {
+  return response.status === 401
+    || response.headers.has(ZED_HEADERS.expiredToken)
+    || response.headers.has(ZED_HEADERS.outdatedToken);
+}
+
+export async function zedLlmFetch(
+  credentials: ZedCredentials,
+  path: string,
+  options: ZedRequestOptions & { fetchInit?: RequestInit; baseUrl?: string } = {},
+): Promise<Response> {
+  const fetchFn = options.fetchFn ?? globalThis.fetch;
+  const request = async (forceRefresh: boolean): Promise<Response> => {
+    const token = await fetchZedLlmToken(credentials, { ...options, forceRefresh });
+    const headers = new Headers(options.fetchInit?.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    try {
+      return await fetchFn(zedUrl(path, options.baseUrl), {
+        ...options.fetchInit,
+        headers,
+        signal: options.signal,
+      });
+    } catch (error) {
+      scrubZedRejection(error, credentials);
+    }
+  };
+  let response = await request(false);
+  if (shouldRefreshZedLlmToken(response)) {
+    await response.body?.cancel().catch(() => undefined);
+    response = await request(true);
+  }
+  return response;
+}
+
+function mapZedModel(raw: unknown): ZedModel | undefined {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  const model = raw as Record<string, unknown>;
+  const id = normalizeModelId(model.id);
+  if (!id) return undefined;
+  const numberField = (...keys: string[]): number | undefined => {
+    for (const key of keys) {
+      const value = model[key];
+      if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+    }
+    return undefined;
+  };
+  const listField = (...keys: string[]): string[] => {
+    for (const key of keys) {
+      if (!Array.isArray(model[key])) continue;
+      return model[key].filter(value => typeof value === "string" && value.trim()).map(value => String(value));
+    }
+    return [];
+  };
+  const contextLength = numberField("max_token_count", "maxTokenCount");
+  const contextLengthInMaxMode = numberField("max_token_count_in_max_mode", "maxTokenCountInMaxMode");
+  const maxOutputTokens = numberField("max_output_tokens", "maxOutputTokens");
+  return {
+    id,
+    name: stringValue(model.display_name) ?? stringValue(model.displayName) ?? id,
+    ...(stringValue(model.provider) ? { provider: stringValue(model.provider) } : {}),
+    ...(contextLength ? { contextLength } : {}),
+    ...(contextLengthInMaxMode ? { contextLengthInMaxMode } : {}),
+    ...(maxOutputTokens ? { maxOutputTokens } : {}),
+    supportsTools: model.supports_tools === true || model.supportsTools === true,
+    supportsImages: model.supports_images === true || model.supportsImages === true,
+    supportsThinking: model.supports_thinking === true || model.supportsThinking === true,
+    supportsDisablingThinking: model.supports_disabling_thinking === true || model.supportsDisablingThinking === true,
+    supportsFastMode: model.supports_fast_mode === true || model.supportsFastMode === true,
+    supportedEffortLevels: listField("supported_effort_levels", "supportedEffortLevels"),
+    isDisabled: model.is_disabled === true || model.isDisabled === true,
+  };
+}
+
+async function readBoundedJson(response: Response, maxBytes: number): Promise<unknown> {
+  const length = Number(response.headers.get("content-length"));
+  if (Number.isFinite(length) && length > maxBytes) {
+    if (response.body) await response.body.cancel().catch(() => undefined);
+    throw new Error("Zed model catalog exceeded the response size limit");
+  }
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("Zed model catalog returned no body");
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => undefined);
+        throw new Error("Zed model catalog exceeded the response size limit");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)) as unknown;
+  } catch {
+    throw new Error("Zed model catalog returned invalid JSON");
+  }
+}
+
+/** Resolve the account-scoped live model roster; the list is display metadata, not a model allowlist. */
+export async function resolveZedModels(
+  credentials: ZedCredentials,
+  options: ZedRequestOptions = {},
+): Promise<ZedModelCatalog> {
+  const key = zedCacheKey(credentials);
+  const cached = modelCache.get(key);
+  if (!options.forceRefresh && cached && cached.expiresAt > Date.now()) return cached;
+  const existing = modelInflight.get(key);
+  if (existing && !options.forceRefresh) return existing;
+  const promise = (async (): Promise<ZedModelCatalog> => {
+    const response = await zedLlmFetch(credentials, "/models", {
+      ...options,
+      fetchInit: {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          [ZED_HEADERS.clientSupportsXai]: "true",
+        },
+      },
+    });
+    if (!response.ok) throw new Error(`Zed model catalog failed: HTTP ${response.status}`);
+    const data = await readBoundedJson(response, MODEL_RESPONSE_MAX_BYTES);
+    const record = data && typeof data === "object" && !Array.isArray(data)
+      ? data as Record<string, unknown>
+      : undefined;
+    const rawModels = Array.isArray(data)
+      ? data
+      : Array.isArray(record?.models)
+      ? record.models
+      : Array.isArray(record?.data)
+        ? record.data
+        : Array.isArray(record?.available_models) ? record.available_models : undefined;
+    if (!rawModels || rawModels.length > MODEL_MAX_ROWS) throw new Error("Zed model catalog returned too many models");
+    const models = rawModels.map(mapZedModel).filter((model): model is ZedModel => !!model && !model.isDisabled);
+    const rawById = new Map<string, Record<string, unknown>>();
+    for (const raw of rawModels) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+      const id = normalizeModelId((raw as Record<string, unknown>).id);
+      if (id) rawById.set(id, raw as Record<string, unknown>);
+    }
+    const catalog: ZedModelCatalog = {
+      expiresAt: Date.now() + MODEL_CACHE_TTL_MS,
+      models,
+      rawById,
+      ...(normalizeModelId(record?.default_model ?? record?.defaultModel) ? { defaultModel: normalizeModelId(record?.default_model ?? record?.defaultModel) } : {}),
+      ...(normalizeModelId(record?.default_fast_model ?? record?.defaultFastModel) ? { defaultFastModel: normalizeModelId(record?.default_fast_model ?? record?.defaultFastModel) } : {}),
+      recommendedModels: (Array.isArray(record?.recommended_models) ? record.recommended_models : Array.isArray(record?.recommendedModels) ? record.recommendedModels : [])
+        .map(normalizeModelId).filter(Boolean),
+    };
+    modelCache.set(key, catalog);
+    return catalog;
+  })();
+  modelInflight.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    if (modelInflight.get(key) === promise) modelInflight.delete(key);
+  }
+}
+
+export function normalizeZedProvider(value: unknown, model: string): "anthropic" | "open_ai" | "google" | "x_ai" {
+  const raw = String(value ?? "").toLowerCase();
+  if (raw === "anthropic") return "anthropic";
+  if (raw === "openai" || raw === "open_ai") return "open_ai";
+  if (raw === "google" || raw === "gemini") return "google";
+  if (raw === "xai" || raw === "x_ai" || raw === "x-ai") return "x_ai";
+  const lowerModel = model.toLowerCase();
+  if (lowerModel.includes("claude")) return "anthropic";
+  if (lowerModel.includes("gemini")) return "google";
+  if (lowerModel.includes("grok") || lowerModel.includes("xai")) return "x_ai";
+  return "open_ai";
+}
+
+export function clearZedCaches(): void {
+  llmTokenCache.clear();
+  organizationCache.clear();
+  modelCache.clear();
+  modelInflight.clear();
+}

package/src/responses/state/snapshot-select.ts

@@ -1,30 +1,34 @@
 import type { StoredResponseState } from "../state";
 
 /**
- * Pick the snapshot entries that fit the byte budgets, in `states` order.
+ * Pick the snapshot entries that fit the byte budgets, in `states` order, and
+ * return them already serialized.
  *
  * Bounded stubs and tombstones are selected before residents: they are the
  * only durable references a spill file has, and demotion is oldest-first, so a
  * single newest-first pass would let resident payloads consume the whole
  * budget ahead of them. Residents then fill what remains, newest-first so the
  * most recent chains survive both legacy snapshot caps.
+ *
+ * Each entry has to be stringified once anyway to measure it, so the kept
+ * strings are returned instead of the entries: serializing the whole selection
+ * again would walk up to the full snapshot budget a second time per write.
  */
 export function selectSnapshotEntries(
   states: ReadonlyMap<string, StoredResponseState>,
   totalMaxBytes: number,
   residentEntryMaxBytes: number,
-): Array<[string, unknown]> {
+): string[] {
   const ordered = [...states].reverse();
-  const persisted = new Map<string, [string, unknown]>();
+  const persisted = new Map<string, string>();
   let total = 0;
   // UTF-8 bytes, not UTF-16 code units: multibyte items otherwise slip past
   // both snapshot caps at up to 2x the intended size.
-  const sizeOf = (entry: [string, unknown]): number => Buffer.byteLength(JSON.stringify(entry), "utf8");
   for (const [id, state] of ordered) {
     if (state.kind === "resident") continue;
     const { sizeBytes: _sizeBytes, ...smallState } = state;
-    const entry: [string, unknown] = [id, smallState];
-    const size = sizeOf(entry);
+    const entry = JSON.stringify([id, smallState]);
+    const size = Buffer.byteLength(entry, "utf8");
     if (total + size > totalMaxBytes) continue;
     total += size;
     persisted.set(id, entry);
@@ -32,18 +36,27 @@ export function selectSnapshotEntries(
   for (const [id, state] of ordered) {
     if (state.kind !== "resident") continue;
     const { sizeBytes: _sizeBytes, kind: _kind, ...resident } = state;
-    const entry: [string, unknown] = [id, resident];
-    const size = sizeOf(entry);
+    const entry = JSON.stringify([id, resident]);
+    const size = Buffer.byteLength(entry, "utf8");
     if (size > residentEntryMaxBytes) continue;
     if (total + size > totalMaxBytes) break;
     total += size;
     persisted.set(id, entry);
   }
   // Emit in map order so reload and count eviction keep the same relative order as `states`.
-  const entries: Array<[string, unknown]> = [];
+  const entries: string[] = [];
   for (const [id] of states) {
     const kept = persisted.get(id);
     if (kept) entries.push(kept);
   }
   return entries;
 }
+
+/**
+ * The snapshot file body for serialized entries. Byte-identical to
+ * `JSON.stringify({ version: 2, states: entries.map(e => JSON.parse(e)) })`: compact
+ * JSON.stringify renders an array element exactly as it renders that value alone.
+ */
+export function snapshotPayload(serializedEntries: readonly string[]): string {
+  return '{"version":2,"states":[' + serializedEntries.join(",") + "]}";
+}

package/src/responses/state.ts

@@ -19,7 +19,7 @@ import {
   writeResponseSpillDurably,
 } from "./spill-store";
 import { collectReferencedSpillFileNames, snapshotReferencedSpillFileNames } from "./state/spill-inspect";
-import { selectSnapshotEntries } from "./state/snapshot-select";
+import { selectSnapshotEntries, snapshotPayload } from "./state/snapshot-select";
 import { clientCarriedPrefixLength, providerIssuedIdentity } from "./state/replay-fingerprint";
 export type { ResponseStateTempRecoveryResult, ResponseStateTempRecoveryOptions } from "./state/temp-recovery";
 export type { ResponseSpillDirInspection } from "./spill-store";
@@ -705,8 +705,7 @@ async function writeBoundedSnapshot(path: string, attemptLimit: number): Promise
   try {
     for (let attempt = 0; attempt < attemptLimit; attempt += 1) {
       const revision = stateRevision;
-      const entries = selectSnapshotEntries(states, snapshotTotalBytes(), SNAPSHOT_ENTRY_MAX_BYTES);
-      const payload = JSON.stringify({ version: 2, states: entries });
+      const payload = snapshotPayload(selectSnapshotEntries(states, snapshotTotalBytes(), SNAPSHOT_ENTRY_MAX_BYTES));
       const payloadBytes = Buffer.byteLength(payload, "utf8");
       const payloadDigest = Bun.hash(payload).toString(36);
       // A mutation does not always change what gets persisted: entries past the