@premai/api-sdk 1.0.45 → 1.0.47

package/dist/cli.mjs

@@ -3,2419 +3,2424 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
-import { parseArgs } from "node:util";
+import { Command } from "commander";
 
-// src/server/create-app.ts
-import express from "express";
+// src/audio/index.ts
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/ciphers/utils.js";
 
-// src/anthropic/http.ts
-import { bytesToHex, randomBytes } from "@noble/ciphers/utils.js";
-var ANTHROPIC_VERSION_DEFAULT = "2023-06-01";
-var ANTHROPIC_VERSION_DATE = /^\d{4}-\d{2}-\d{2}$/;
-function isAnthropicApiVersionSupported(version) {
-  if (version === ANTHROPIC_VERSION_DEFAULT) {
-    return true;
+// src/config.ts
+var endpoints = {
+  enclave: process.env.ENCLAVE_URL,
+  proxy: process.env.PROXY_URL
+};
+var DEFAULT_REQUEST_TIMEOUT_MS = 600000;
+var DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+
+// src/utils/attestation.ts
+var cachedPrem;
+async function loadPrem() {
+  if (cachedPrem)
+    return cachedPrem;
+  const isBare = typeof globalThis.Bare !== "undefined";
+  if (isBare) {
+    cachedPrem = await (async (s, y) => await import(s, y))("@premai/reticle", { with: { type: "script" } });
+    return cachedPrem;
   }
-  return ANTHROPIC_VERSION_DATE.test(version);
+  cachedPrem = await import("@premai/reticle");
+  return cachedPrem;
 }
-function newAnthropicRequestId() {
-  return `req_${bytesToHex(randomBytes(12))}`;
+function isAttestationError(err) {
+  return err instanceof Error && err.name === "AttestationError";
 }
-function newAnthropicMessageId() {
-  return `msg_${bytesToHex(randomBytes(12))}`;
+var ATTEST_TTL_MS = 30000;
+var ATTEST_CACHE_MAX = 500;
+var ATTEST_MAX_ATTEMPTS = 4;
+var ATTEST_RETRY_BASE_MS = 250;
+var ATTEST_RETRY_MAX_MS = 2000;
+var TRANSIENT_PATTERNS = [
+  /EOF while parsing/i,
+  /error decoding response body/i,
+  /connection (reset|closed|refused)/i,
+  /socket hang up/i,
+  /ETIMEDOUT/i
+];
+var attestCache = new Map;
+var attestInflight = new Map;
+function attestCacheKey(apiKey, model) {
+  return `${apiKey}|${model ?? ""}`;
 }
-function extractAnthropicApiKey(req) {
-  const raw = req.headers["x-api-key"];
-  if (typeof raw === "string" && raw.length > 0) {
-    return raw;
-  }
-  if (Array.isArray(raw) && raw[0]) {
-    return raw[0];
-  }
-  const authHeader = req.headers.authorization;
-  if (!authHeader) {
-    return null;
-  }
-  if (authHeader.startsWith("Bearer ")) {
-    return authHeader.slice(7);
+function pruneExpired(now) {
+  for (const [key, entry] of attestCache) {
+    if (entry.expires <= now) {
+      attestCache.delete(key);
+    } else {
+      break;
+    }
   }
-  return authHeader;
 }
-function getAnthropicVersionHeader(req) {
-  const raw = req.headers["anthropic-version"];
-  if (typeof raw === "string" && raw.length > 0) {
-    return raw;
+function isTransientError(err) {
+  const messages = [];
+  if (err instanceof Error) {
+    messages.push(err.message);
   }
-  if (Array.isArray(raw) && raw[0]) {
-    return raw[0];
+  if (isAttestationError(err) && Array.isArray(err.cause)) {
+    messages.push(...err.cause);
   }
-  return null;
+  return messages.some((m) => TRANSIENT_PATTERNS.some((re) => re.test(m)));
 }
-function resolveAnthropicVersion(req) {
-  const header = getAnthropicVersionHeader(req);
-  const version = header ?? ANTHROPIC_VERSION_DEFAULT;
-  if (!isAnthropicApiVersionSupported(version)) {
-    return {
-      ok: false,
-      message: `Unsupported anthropic-version: ${version}. Expected a dated version (YYYY-MM-DD) or ${ANTHROPIC_VERSION_DEFAULT}.`
-    };
-  }
-  return { ok: true, version };
+function backoffDelayMs(attempt) {
+  const exp = ATTEST_RETRY_BASE_MS * 2 ** (attempt - 1);
+  const capped = Math.min(exp, ATTEST_RETRY_MAX_MS);
+  const jitter = Math.floor(Math.random() * (capped / 2));
+  return capped + jitter;
 }
-function sendAnthropicHttpError(res, status, errorType, message, requestId) {
-  res.setHeader("request-id", requestId);
-  res.status(status).json({
-    type: "error",
-    error: { type: errorType, message },
-    request_id: requestId
-  });
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function httpStatusToAnthropicErrorType(status) {
-  if (status === 401) {
-    return "authentication_error";
-  }
-  if (status === 402) {
-    return "billing_error";
-  }
-  if (status === 403) {
-    return "permission_error";
-  }
-  if (status === 404) {
-    return "not_found_error";
-  }
-  if (status === 413) {
-    return "request_too_large";
-  }
-  if (status === 429) {
-    return "rate_limit_error";
-  }
-  if (status === 504) {
-    return "timeout_error";
+function safeFree(obj) {
+  if (typeof obj?.free !== "function")
+    return;
+  try {
+    obj.free();
+  } catch {}
+}
+async function attemptAttest(apiKey, options) {
+  const prem = await loadPrem();
+  let client;
+  let attested;
+  let headers;
+  let sessionId;
+  try {
+    client = await new prem.ClientBuilder(endpoints.proxy ?? "").with_authorization(apiKey).build();
+    if (options.model) {
+      client.set_query(new prem.QueryParams().with("model", options.model));
+    }
+    attested = await client.attest();
+    headers = attested.headers();
+    sessionId = headers.cpu()?.get("x-session-id") ?? headers.gpu()?.get("x-session-id") ?? null;
+  } finally {
+    safeFree(headers);
+    safeFree(attested);
+    safeFree(client);
   }
-  if (status === 529) {
-    return "overloaded_error";
+  if (sessionId === null) {
+    throw new Error("missing x-session-id issued by attestation");
   }
-  if (status >= 400 && status < 500) {
-    return "invalid_request_error";
+  return sessionId;
+}
+async function runAttest(apiKey, options) {
+  let lastErr;
+  for (let attempt = 1;attempt <= ATTEST_MAX_ATTEMPTS; attempt++) {
+    try {
+      return await attemptAttest(apiKey, options);
+    } catch (err) {
+      lastErr = err;
+      if (attempt === ATTEST_MAX_ATTEMPTS || !isTransientError(err)) {
+        throw err;
+      }
+      await delay(backoffDelayMs(attempt));
+    }
   }
-  return "api_error";
+  throw lastErr;
 }
-function extractErrorMessage(err) {
-  if (!err || typeof err !== "object") {
+async function attest(apiKey, options = { enabled: true }) {
+  if (!options.enabled)
     return null;
+  const key = attestCacheKey(apiKey, options.model);
+  const now = Date.now();
+  const cached = attestCache.get(key);
+  if (cached) {
+    if (cached.expires > now)
+      return cached.sessionId;
+    attestCache.delete(key);
   }
-  const o = err;
-  if (typeof o.message === "string" && o.message.length > 0) {
-    return o.message;
-  }
-  if (typeof o.error === "string" && o.error.length > 0) {
-    return o.error;
+  const inflight = attestInflight.get(key);
+  if (inflight) {
+    return inflight;
   }
-  if (o.error && typeof o.error === "object") {
-    const nested = o.error.message;
-    if (typeof nested === "string" && nested.length > 0) {
-      return nested;
+  const work = runAttest(apiKey, options).then((sessionId) => {
+    const insertTime = Date.now();
+    pruneExpired(insertTime);
+    attestCache.set(key, { sessionId, expires: insertTime + ATTEST_TTL_MS });
+    if (attestCache.size > ATTEST_CACHE_MAX) {
+      const oldest = attestCache.keys().next().value;
+      if (oldest)
+        attestCache.delete(oldest);
     }
-  }
-  return null;
+    return sessionId;
+  }).finally(() => {
+    attestInflight.delete(key);
+  });
+  attestInflight.set(key, work);
+  return work;
 }
-function looksLikeApiErrorResponse(err) {
-  if (!err || typeof err !== "object")
-    return false;
-  const o = err;
-  if (typeof o.status !== "number")
-    return false;
-  return "error" in o || "message" in o;
+
+// src/utils/crypto.ts
+import { aeskwp } from "@noble/ciphers/aes.js";
+import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { bytesToHex, hexToBytes, managedNonce, randomBytes } from "@noble/ciphers/utils.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { XWing } from "@noble/post-quantum/hybrid.js";
+function createMLKEMEncapsulation(publicKeyHex) {
+  return XWing.encapsulate(hexToBytes(publicKeyHex));
 }
-function mapUnknownErrorToAnthropicResponse(err, res, requestId) {
-  if (looksLikeApiErrorResponse(err)) {
-    const status = err.status >= 400 && err.status < 600 ? err.status : 500;
-    const message2 = extractErrorMessage(err) ?? "Request failed";
-    const errorType = httpStatusToAnthropicErrorType(status);
-    sendAnthropicHttpError(res, status, errorType, message2, requestId);
-    return;
+function encryptPayload(sharedSecret, data) {
+  const nonce = randomBytes(24);
+  const chacha = xchacha20poly1305(sharedSecret, nonce);
+  let encodedData;
+  if (data instanceof Uint8Array) {
+    encodedData = data;
+  } else if (typeof data === "string") {
+    encodedData = new TextEncoder().encode(data);
+  } else {
+    encodedData = new TextEncoder().encode(JSON.stringify(data));
   }
-  const message = extractErrorMessage(err) ?? (err instanceof Error ? err.message : "Internal server error");
-  sendAnthropicHttpError(res, 500, "api_error", message, requestId);
+  const encrypted = chacha.encrypt(encodedData);
+  return { encrypted, nonce };
 }
-function writeAnthropicSseEvent(res, event, data) {
-  res.write(`event: ${event}
-data: ${JSON.stringify(data)}
-
-`);
-}
-
-// src/anthropic/to-openai.ts
-class AnthropicRequestValidationError extends Error {
-  status = 400;
-  anthropicType = "invalid_request_error";
-  constructor(message) {
-    super(message);
-    this.name = "AnthropicRequestValidationError";
+function decryptPayload(encryptedData, sharedSecret, nonce) {
+  const chacha = xchacha20poly1305(sharedSecret, nonce);
+  const encrypted = hexToBytes(encryptedData);
+  const decrypted = chacha.decrypt(encrypted);
+  const str = new TextDecoder().decode(decrypted);
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
   }
 }
-function systemToOpenAiMessages(system) {
-  if (typeof system === "string") {
-    if (system.length === 0) {
-      return [];
+async function getEnclavePublicKey(timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${endpoints.enclave}/publicKey`, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch enclave public key: ${response.status} ${response.statusText}`);
     }
-    return [{ role: "system", content: system }];
-  }
-  if (Array.isArray(system)) {
-    const parts = [];
-    for (const block of system) {
-      if (block && block.type === "text" && typeof block.text === "string") {
-        parts.push(block.text);
-      } else if (block && typeof block === "object") {
-        console.warn(`[proxy] system block type "${block.type}" is not supported and will be ignored.`);
-      }
+    const data = await response.json();
+    if (!data.publicKey || typeof data.publicKey !== "string") {
+      throw new Error("Invalid public key response from enclave");
     }
-    if (parts.length === 0) {
-      return [];
+    return data.publicKey;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Enclave public key request timed out after ${timeoutMs}ms`);
     }
-    return [{ role: "system", content: parts.join(`
-
-`) }];
+    throw new Error(`Failed to get enclave public key: ${error instanceof Error ? error.message : error}`);
+  } finally {
+    clearTimeout(timeoutId);
   }
-  if (system.type === "text" && typeof system.text === "string") {
-    return [{ role: "system", content: system.text }];
+}
+async function generateEncryptionKeys(timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  return createMLKEMEncapsulation(enclavePublicKey);
+}
+function keyIdFromKEK(kek, context = "kek:v1", length = 16) {
+  const ctx = new TextEncoder().encode(context);
+  const input = new Uint8Array(kek.length + ctx.length);
+  input.set(kek, 0);
+  input.set(ctx, kek.length);
+  const digest = sha256(input);
+  return digest.slice(0, length);
+}
+function encryptWithDEK(dek, plaintext) {
+  const aead = managedNonce(xchacha20poly1305)(dek);
+  return aead.encrypt(plaintext);
+}
+function encryptMetadataWithDEK(dek, metadata) {
+  const encoded = new TextEncoder().encode(metadata);
+  const encrypted = encryptWithDEK(dek, encoded);
+  return bytesToHex(encrypted);
+}
+function wrapDEK(kek, dek) {
+  const kw = aeskwp(kek);
+  return kw.encrypt(dek);
+}
+function unwrapDEK(kek, wrappedDEK) {
+  const kw = aeskwp(kek);
+  return kw.decrypt(wrappedDEK);
+}
+function decryptWithDEK(dek, encryptedContent) {
+  const aead = managedNonce(xchacha20poly1305)(dek);
+  return aead.decrypt(encryptedContent);
+}
+
+// src/utils/error.ts
+async function throwIfErrorResponse(response) {
+  let raw;
+  try {
+    raw = await response.json();
+    if (!raw.status)
+      raw = { ...raw, status: response.status };
+  } catch {
+    raw = {
+      status: response.status,
+      data: null,
+      error: response.statusText || `HTTP ${response.status}`,
+      message: null
+    };
   }
-  throw new AnthropicRequestValidationError("Invalid system parameter shape.");
+  throw raw;
 }
-function toolResultContentToString(content) {
-  if (typeof content === "string") {
-    return content;
+
+// src/utils/files.ts
+var getFileName = (file) => {
+  if (file instanceof File) {
+    return file.name;
   }
-  if (content === null || content === undefined) {
-    return "";
+  if (file instanceof Blob) {
+    return;
   }
-  if (Array.isArray(content)) {
-    const parts = [];
-    for (const block of content) {
-      if (block && typeof block === "object" && "type" in block && block.type === "text" && typeof block.text === "string") {
-        parts.push(block.text);
-      } else {
-        parts.push(JSON.stringify(block));
-      }
-    }
-    return parts.join(`
-`);
+  const fileAny = file;
+  if (fileAny.path) {
+    const path = typeof fileAny.path === "string" ? fileAny.path : fileAny.path.toString();
+    return path.split("/").pop() || path.split("\\").pop() || path;
   }
-  return JSON.stringify(content);
-}
-function anthropicImageBlockToOpenAIPart(part) {
-  const source = part.source;
-  if (!source || typeof source !== "object") {
-    return null;
+  if (file instanceof Uint8Array || file instanceof ArrayBuffer) {
+    return;
   }
-  const s = source;
-  if (s.type === "base64" && typeof s.data === "string" && s.data.length > 0) {
-    const mediaType = typeof s.media_type === "string" && s.media_type.length > 0 ? s.media_type : "image/png";
-    return {
-      type: "image_url",
-      image_url: { url: `data:${mediaType};base64,${s.data}` }
-    };
+  return;
+};
+
+// src/audio/index.ts
+async function readUploadableToUint8Array(file) {
+  if (file instanceof Uint8Array) {
+    return file;
   }
-  if (s.type === "url" && typeof s.url === "string" && s.url.length > 0) {
-    return { type: "image_url", image_url: { url: s.url } };
+  if (file instanceof ArrayBuffer) {
+    return new Uint8Array(file);
   }
-  return null;
-}
-function anthropicUserContentToOpenAIMessages(content) {
-  if (typeof content === "string") {
-    return [{ role: "user", content }];
+  if (typeof file.arrayBuffer === "function") {
+    const blob = file;
+    const buffer = await blob.arrayBuffer();
+    return new Uint8Array(buffer);
   }
-  const out = [];
-  const partsBuf = [];
-  const flushParts = () => {
-    if (partsBuf.length === 0) {
-      return;
-    }
-    if (partsBuf.length === 1 && partsBuf[0].type === "text") {
-      out.push({ role: "user", content: partsBuf[0].text });
-    } else {
-      out.push({ role: "user", content: [...partsBuf] });
-    }
-    partsBuf.length = 0;
-  };
-  for (const part of content) {
-    if (!part || typeof part !== "object") {
-      throw new AnthropicRequestValidationError("Invalid message content entry.");
-    }
-    if (part.type === "text" && typeof part.text === "string") {
-      partsBuf.push({
-        type: "text",
-        text: part.text
+  const fileAny = file;
+  if (typeof fileAny.on === "function" && (typeof fileAny.read === "function" || typeof fileAny.pipe === "function")) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+      fileAny.on("data", (chunk) => {
+        if (Buffer.isBuffer(chunk)) {
+          chunks.push(new Uint8Array(chunk));
+        } else if (chunk instanceof Uint8Array) {
+          chunks.push(chunk);
+        } else if (typeof chunk === "object" && chunk !== null) {
+          chunks.push(new Uint8Array(Buffer.from(chunk)));
+        }
       });
-      continue;
-    }
-    if (part.type === "image") {
-      const imgPart = anthropicImageBlockToOpenAIPart(part);
-      if (imgPart) {
-        partsBuf.push(imgPart);
-      }
-      continue;
-    }
-    if (part.type === "tool_result") {
-      flushParts();
-      const id = part.tool_use_id;
-      const rawContent = part.content;
-      if (typeof id !== "string" || id.length === 0) {
-        throw new AnthropicRequestValidationError("tool_result blocks require a non-empty tool_use_id.");
-      }
-      out.push({
-        role: "tool",
-        tool_call_id: id,
-        content: toolResultContentToString(rawContent)
+      fileAny.on("end", () => {
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        resolve(result);
       });
-    }
+      fileAny.on("error", (err) => reject(err));
+    });
   }
-  flushParts();
-  return out;
+  throw new Error("Unsupported file type for audio transcription");
 }
-function anthropicAssistantContentToOpenAI(content) {
-  if (typeof content === "string") {
-    return { role: "assistant", content };
-  }
-  const textParts = [];
-  const toolCalls = [];
-  for (const part of content) {
-    if (!part || typeof part !== "object") {
-      throw new AnthropicRequestValidationError("Invalid message content entry.");
-    }
-    if (part.type === "text" && typeof part.text === "string") {
-      textParts.push(part.text);
-      continue;
-    }
-    if (part.type === "tool_use") {
-      const p = part;
-      if (typeof p.id !== "string" || p.id.length === 0) {
-        throw new AnthropicRequestValidationError("tool_use blocks require a non-empty id.");
-      }
-      if (typeof p.name !== "string" || p.name.length === 0) {
-        throw new AnthropicRequestValidationError("tool_use blocks require a non-empty name.");
-      }
-      const args = typeof p.input === "string" ? p.input : JSON.stringify(p.input ?? {});
-      toolCalls.push({
-        id: p.id,
-        type: "function",
-        function: { name: p.name, arguments: args }
-      });
-    }
-  }
-  const msg = {
-    role: "assistant",
-    content: textParts.length > 0 ? textParts.join(`
-`) : null
+async function preprocessAudioRequest(body, encryptionKeys) {
+  const { cipherText, sharedSecret } = encryptionKeys;
+  const audioData = await readUploadableToUint8Array(body.file);
+  const isDeepgram = body.model.startsWith("deepgram/");
+  const requestBody = isDeepgram ? {
+    model: body.model,
+    diarize: body.diarize,
+    smart_format: body.smart_format
+  } : {
+    model: body.model,
+    language: body.language,
+    prompt: body.prompt,
+    response_format: body.response_format,
+    temperature: body.temperature,
+    timestamp_granularities: body.timestamp_granularities
+  };
+  const cleanedBody = Object.fromEntries(Object.entries(requestBody).filter(([_, v]) => v !== undefined));
+  const { encrypted, nonce } = encryptPayload(sharedSecret, cleanedBody);
+  const { encrypted: encryptedFile, nonce: fileNonce } = encryptPayload(sharedSecret, audioData);
+  const fileName = getFileName(body.file) || "audio.mp3";
+  const { encrypted: encryptedFileName, nonce: fileNameNonce } = encryptPayload(sharedSecret, fileName);
+  return {
+    body: {
+      cipherText: bytesToHex2(cipherText),
+      encryptedInference: bytesToHex2(encrypted),
+      nonce: bytesToHex2(nonce),
+      fileNameNonce: bytesToHex2(fileNameNonce),
+      encryptedFileName: bytesToHex2(encryptedFileName),
+      fileNonce: bytesToHex2(fileNonce),
+      encryptedFile: bytesToHex2(encryptedFile),
+      model: body.model
+    },
+    sharedSecret
   };
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
-  }
-  return msg;
 }
-function anthropicToolsToOpenAI(tools) {
-  if (tools === undefined) {
-    return;
-  }
-  if (!Array.isArray(tools)) {
-    throw new AnthropicRequestValidationError("tools must be an array.");
-  }
-  const out = [];
-  for (const t of tools) {
-    if (!t || typeof t !== "object") {
-      throw new AnthropicRequestValidationError("Invalid tool entry.");
-    }
-    const name = t.name;
-    const desc = t.description;
-    const schema = t.input_schema;
-    if (typeof name !== "string" || name.length === 0) {
-      throw new AnthropicRequestValidationError("Each tool must include a non-empty name.");
-    }
-    if (schema !== undefined && (typeof schema !== "object" || schema === null)) {
-      throw new AnthropicRequestValidationError("tool input_schema must be an object when provided.");
-    }
-    out.push({
-      type: "function",
-      function: {
-        name,
-        ...typeof desc === "string" ? { description: desc } : {},
-        parameters: schema ?? {
-          type: "object",
-          properties: {}
-        }
-      }
-    });
+async function postprocessTranscriptionResponse(response, sharedSecret) {
+  const responseData = await response.json();
+  const data = responseData.data;
+  if (!data.encryptedResponse || !data.nonce) {
+    throw new Error("Invalid transcription response: missing encryptedResponse or nonce");
   }
-  return out;
+  const responseNonce = hexToBytes2(data.nonce);
+  return decryptPayload(data.encryptedResponse, sharedSecret, responseNonce);
 }
-function anthropicToolChoiceToOpenAI(toolChoice) {
-  if (toolChoice === undefined) {
-    return;
-  }
-  if (typeof toolChoice !== "object" || toolChoice === null || !("type" in toolChoice)) {
-    throw new AnthropicRequestValidationError("Invalid tool_choice shape.");
-  }
-  const tc = toolChoice;
-  switch (tc.type) {
-    case "auto":
-      return "auto";
-    case "none":
-      return "none";
-    case "any":
-      return "required";
-    case "tool": {
-      if (typeof tc.name !== "string" || tc.name.length === 0) {
-        throw new AnthropicRequestValidationError('tool_choice type "tool" requires a non-empty name.');
-      }
-      return { type: "function", function: { name: tc.name } };
-    }
-    default:
-      throw new AnthropicRequestValidationError(`Unsupported tool_choice type "${tc.type}".`);
+async function postprocessTranslationResponse(response, sharedSecret) {
+  const responseData = await response.json();
+  const data = responseData.data;
+  if (!data.encryptedResponse || !data.nonce) {
+    throw new Error("Invalid translation response: missing encryptedResponse or nonce");
   }
+  const responseNonce = hexToBytes2(data.nonce);
+  return decryptPayload(data.encryptedResponse, sharedSecret, responseNonce);
 }
-function anthropicMessagesCreateToOpenAI(body) {
-  if (typeof body.model !== "string" || !body.model) {
-    throw new AnthropicRequestValidationError("model is required.");
-  }
-  if (typeof body.max_tokens !== "number" || !Number.isFinite(body.max_tokens)) {
-    throw new AnthropicRequestValidationError("max_tokens is required and must be a number.");
-  }
-  if (!Array.isArray(body.messages)) {
-    throw new AnthropicRequestValidationError("messages must be an array.");
-  }
-  const messages = [];
-  if (body.system !== undefined) {
-    messages.push(...systemToOpenAiMessages(body.system));
-  }
-  for (const m of body.messages) {
-    if (m.role !== "user" && m.role !== "assistant") {
-      throw new AnthropicRequestValidationError(`Invalid message role "${m.role}".`);
-    }
-    if (m.role === "user") {
-      messages.push(...anthropicUserContentToOpenAIMessages(m.content));
-    } else {
-      messages.push(anthropicAssistantContentToOpenAI(m.content));
-    }
-  }
-  const isStreaming = Boolean(body.stream);
-  const params = {
+async function preprocessAudioTranslationRequest(body, encryptionKeys) {
+  const { cipherText, sharedSecret } = encryptionKeys;
+  const audioData = await readUploadableToUint8Array(body.file);
+  const requestBody = {
     model: body.model,
-    messages,
-    max_tokens: body.max_tokens,
-    stream: isStreaming
+    prompt: body.prompt,
+    response_format: body.response_format,
+    temperature: body.temperature
+  };
+  const cleanedBody = Object.fromEntries(Object.entries(requestBody).filter(([_, v]) => v !== undefined));
+  const { encrypted, nonce } = encryptPayload(sharedSecret, cleanedBody);
+  const { encrypted: encryptedFile, nonce: fileNonce } = encryptPayload(sharedSecret, audioData);
+  const fileName = getFileName(body.file) || "audio.mp3";
+  const { encrypted: encryptedFileName, nonce: fileNameNonce } = encryptPayload(sharedSecret, fileName);
+  return {
+    body: {
+      cipherText: bytesToHex2(cipherText),
+      encryptedInference: bytesToHex2(encrypted),
+      nonce: bytesToHex2(nonce),
+      fileNameNonce: bytesToHex2(fileNameNonce),
+      encryptedFileName: bytesToHex2(encryptedFileName),
+      fileNonce: bytesToHex2(fileNonce),
+      encryptedFile: bytesToHex2(encryptedFile),
+      model: body.model
+    },
+    sharedSecret
   };
-  if (isStreaming) {
-    params.stream_options = { include_usage: true };
-  }
-  const tools = anthropicToolsToOpenAI(body.tools);
-  if (tools !== undefined && tools.length > 0) {
-    params.tools = tools;
-  }
-  const toolChoice = anthropicToolChoiceToOpenAI(body.tool_choice);
-  if (toolChoice !== undefined) {
-    params.tool_choice = toolChoice;
-  }
-  if (body.stop_sequences !== undefined) {
-    if (!Array.isArray(body.stop_sequences) || !body.stop_sequences.every((s) => typeof s === "string")) {
-      throw new AnthropicRequestValidationError("stop_sequences must be an array of strings.");
-    }
-    params.stop = body.stop_sequences;
-  }
-  if (typeof body.temperature === "number") {
-    params.temperature = body.temperature;
-  }
-  if (typeof body.top_p === "number") {
-    params.top_p = body.top_p;
-  }
-  if (typeof body.top_k === "number") {
-    console.warn("[proxy] top_k is not supported by the OpenAI API and will be ignored.");
-  }
-  return params;
 }
-
-// src/anthropic/count-tokens-route.ts
-function extractTextCharCount(body) {
-  let len = 0;
-  if (typeof body.system === "string") {
-    len += body.system.length;
-  } else if (Array.isArray(body.system)) {
-    for (const block of body.system) {
-      if (block && block.type === "text" && typeof block.text === "string") {
-        len += block.text.length;
+function createAudioClient(apiKey, encryptionKeys, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
+  async function createTranscription(body) {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
+    try {
+      const sessionId = await attest(apiKey, { model: body.model, enabled: attest2 });
+      const encryptedRequest = await preprocessAudioRequest(body, encryptionKeys);
+      const response = await fetch(`${endpoints.proxy}/rvenc/audio/transcriptions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: apiKey,
+          ...sessionId && { "X-Session-Id": sessionId }
+        },
+        body: JSON.stringify(encryptedRequest.body),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        await throwIfErrorResponse(response);
       }
-    }
-  } else if (body.system && typeof body.system === "object" && body.system.type === "text") {
-    len += body.system.text.length;
-  }
-  for (const msg of body.messages) {
-    if (typeof msg.content === "string") {
-      len += msg.content.length;
-    } else if (Array.isArray(msg.content)) {
-      for (const part of msg.content) {
-        if (!part || typeof part !== "object")
-          continue;
-        if (part.type === "text" && typeof part.text === "string") {
-          len += part.text.length;
-        } else if (part.type === "tool_result") {
-          const c = part.content;
-          if (typeof c === "string") {
-            len += c.length;
-          }
-        }
+      clearTimeout(timeoutId);
+      return await postprocessTranscriptionResponse(response, encryptedRequest.sharedSecret);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timed out after ${requestTimeoutMs}ms`);
       }
+      throw error;
     }
   }
-  if (Array.isArray(body.tools)) {
-    len += JSON.stringify(body.tools).length;
-  }
-  return len;
-}
-function registerAnthropicCountTokensRoute(router, _deps) {
-  router.post("/v1/messages/count_tokens", async (req, res) => {
-    const requestId = newAnthropicRequestId();
-    res.setHeader("request-id", requestId);
-    const versionResult = resolveAnthropicVersion(req);
-    if (!versionResult.ok) {
-      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
-    }
-    const apiKey = extractAnthropicApiKey(req);
-    if (!apiKey) {
-      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
-    }
-    try {
-      const raw = req.body;
-      const body = {
-        ...raw,
-        max_tokens: typeof raw.max_tokens === "number" && Number.isFinite(raw.max_tokens) ? raw.max_tokens : 4096,
-        stream: false
-      };
-      anthropicMessagesCreateToOpenAI(body);
-      const input_tokens = Math.max(1, Math.ceil(extractTextCharCount(body) / 4));
-      res.json({ input_tokens });
-    } catch (err) {
-      if (err instanceof AnthropicRequestValidationError) {
-        return sendAnthropicHttpError(res, err.status, err.anthropicType, err.message, requestId);
-      }
-      mapUnknownErrorToAnthropicResponse(err, res, requestId);
-    }
-  });
-}
-
-// src/anthropic/from-openai.ts
-function openAiFinishReasonToAnthropic(finish) {
-  if (!finish) {
-    return { stop_reason: null, stop_sequence: null };
-  }
-  switch (finish) {
-    case "stop":
-      return { stop_reason: "end_turn", stop_sequence: null };
-    case "length":
-      return { stop_reason: "max_tokens", stop_sequence: null };
-    case "tool_calls":
-      return { stop_reason: "tool_use", stop_sequence: null };
-    case "content_filter":
-      return { stop_reason: "refusal", stop_sequence: null };
-    default:
-      return { stop_reason: "end_turn", stop_sequence: null };
-  }
-}
-function extractTextFromAssistantContent(content) {
-  if (content == null) {
-    return "";
-  }
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  const parts = [];
-  for (const p of content) {
-    if (typeof p === "string") {
-      parts.push(p);
-      continue;
-    }
-    if (p && typeof p === "object" && "type" in p && p.type === "text" && "text" in p) {
-      parts.push(String(p.text));
-    }
-  }
-  return parts.join("");
-}
-function openAIChatCompletionToAnthropicMessage(completion, requestModel) {
-  const choice = completion.choices[0];
-  const message = choice?.message;
-  const contentText = message ? extractTextFromAssistantContent(message.content) : "";
-  const content = [];
-  if (contentText.length > 0) {
-    content.push({ type: "text", text: contentText });
-  }
-  if (message?.tool_calls?.length) {
-    for (const tc of message.tool_calls) {
-      if (tc.type !== "function") {
-        continue;
-      }
-      let input = {};
-      try {
-        input = JSON.parse(tc.function.arguments || "{}");
-      } catch {
-        input = { _raw_arguments: tc.function.arguments ?? "" };
-      }
-      content.push({
-        type: "tool_use",
-        id: tc.id,
-        name: tc.function.name,
-        input
-      });
-    }
-  }
-  if (content.length === 0) {
-    content.push({ type: "text", text: "" });
-  }
-  const { stop_reason, stop_sequence } = openAiFinishReasonToAnthropic(choice?.finish_reason);
-  const u = completion.usage;
-  const usage = {
-    input_tokens: u?.prompt_tokens ?? 0,
-    output_tokens: u?.completion_tokens ?? 0
-  };
-  return {
-    id: newAnthropicMessageId(),
-    type: "message",
-    role: "assistant",
-    content,
-    model: requestModel,
-    stop_reason,
-    stop_sequence,
-    usage
-  };
-}
-function chunkFinishToAnthropic(finish) {
-  if (!finish) {
-    return null;
-  }
-  return openAiFinishReasonToAnthropic(finish).stop_reason;
-}
-async function pipeOpenAIChunkStreamToAnthropicSse(res, stream, options) {
-  const { anthropicModel, messageId } = options;
-  let textBlockOpen = false;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let stopReason = null;
-  const toolStates = new Map;
-  let nextAnthropicIndex = 0;
-  let textBlockIndex = null;
-  writeAnthropicSseEvent(res, "message_start", {
-    type: "message_start",
-    message: {
-      id: messageId,
-      type: "message",
-      role: "assistant",
-      content: [],
-      model: anthropicModel,
-      stop_reason: null,
-      stop_sequence: null,
-      usage: { input_tokens: inputTokens, output_tokens: outputTokens }
-    }
-  });
-  const ensureTextBlock = () => {
-    if (textBlockOpen) {
-      return;
-    }
-    textBlockIndex = nextAnthropicIndex++;
-    textBlockOpen = true;
-    writeAnthropicSseEvent(res, "content_block_start", {
-      type: "content_block_start",
-      index: textBlockIndex,
-      content_block: { type: "text", text: "" }
-    });
-  };
-  const closeTextBlockIfOpen = () => {
-    if (!textBlockOpen || textBlockIndex === null) {
-      return;
-    }
-    writeAnthropicSseEvent(res, "content_block_stop", {
-      type: "content_block_stop",
-      index: textBlockIndex
-    });
-    textBlockOpen = false;
-  };
-  const getOrCreateTool = (openAiIdx) => {
-    let st = toolStates.get(openAiIdx);
-    if (!st) {
-      st = {
-        anthropicIndex: nextAnthropicIndex++,
-        id: "",
-        name: "",
-        lastArgs: "",
-        argsEmittedLen: 0,
-        started: false,
-        stopped: false
-      };
-      toolStates.set(openAiIdx, st);
-    }
-    return st;
-  };
-  const flushToolArgs = (st) => {
-    if (!st.started || st.lastArgs.length <= st.argsEmittedLen) {
-      return;
-    }
-    const partial = st.lastArgs.slice(st.argsEmittedLen);
-    st.argsEmittedLen = st.lastArgs.length;
-    writeAnthropicSseEvent(res, "content_block_delta", {
-      type: "content_block_delta",
-      index: st.anthropicIndex,
-      delta: {
-        type: "input_json_delta",
-        partial_json: partial
-      }
-    });
+  const transcriptionsClient = {
+    create: createTranscription
   };
-  try {
-    for await (const chunk of stream) {
-      if (chunk.usage) {
-        const u = chunk.usage;
-        inputTokens = u.prompt_tokens ?? inputTokens;
-        outputTokens = u.completion_tokens ?? outputTokens;
-      }
-      const choice = chunk.choices?.[0];
-      if (!choice) {
-        continue;
-      }
-      const delta = choice.delta;
-      if (typeof delta?.content === "string" && delta.content.length > 0) {
-        ensureTextBlock();
-        if (textBlockIndex !== null) {
-          writeAnthropicSseEvent(res, "content_block_delta", {
-            type: "content_block_delta",
-            index: textBlockIndex,
-            delta: { type: "text_delta", text: delta.content }
-          });
-        }
-      }
-      if (delta?.tool_calls?.length) {
-        closeTextBlockIfOpen();
-        for (const tc of delta.tool_calls) {
-          const idx = typeof tc.index === "number" && Number.isFinite(tc.index) ? tc.index : 0;
-          const st = getOrCreateTool(idx);
-          if (typeof tc.id === "string" && tc.id.length > 0) {
-            st.id = tc.id;
-          }
-          const fn = tc.function;
-          if (fn?.name && fn.name.length > 0) {
-            st.name = fn.name;
-          }
-          if (typeof fn?.arguments === "string") {
-            st.lastArgs += fn.arguments;
-          }
-          if (!st.started && st.id.length > 0 && st.name.length > 0) {
-            writeAnthropicSseEvent(res, "content_block_start", {
-              type: "content_block_start",
-              index: st.anthropicIndex,
-              content_block: {
-                type: "tool_use",
-                id: st.id,
-                name: st.name
-              }
-            });
-            st.started = true;
-          }
-          if (st.started) {
-            flushToolArgs(st);
-          }
-        }
-      }
-      if (choice.finish_reason) {
-        const mapped = chunkFinishToAnthropic(choice.finish_reason);
-        if (mapped) {
-          stopReason = mapped;
-        }
-      }
-    }
-    closeTextBlockIfOpen();
-    const sortedTools = [...toolStates.values()].sort((a, b) => a.anthropicIndex - b.anthropicIndex);
-    for (const st of sortedTools) {
-      if (st.started && !st.stopped) {
-        writeAnthropicSseEvent(res, "content_block_stop", {
-          type: "content_block_stop",
-          index: st.anthropicIndex
-        });
-        st.stopped = true;
-      }
-    }
-    writeAnthropicSseEvent(res, "message_delta", {
-      type: "message_delta",
-      delta: { stop_reason: stopReason, stop_sequence: null },
-      usage: {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens
-      }
-    });
-    writeAnthropicSseEvent(res, "message_stop", { type: "message_stop" });
-    res.end();
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Stream error";
-    writeAnthropicSseEvent(res, "error", {
-      type: "error",
-      error: { type: "api_error", message }
-    });
-    res.end();
-  }
-}
-
-// src/anthropic/messages-route.ts
-function registerAnthropicMessagesRoute(router, deps) {
-  router.post("/v1/messages", async (req, res) => {
-    const requestId = newAnthropicRequestId();
-    res.setHeader("request-id", requestId);
-    const versionResult = resolveAnthropicVersion(req);
-    if (!versionResult.ok) {
-      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
-    }
-    const apiKey = extractAnthropicApiKey(req);
-    if (!apiKey) {
-      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
-    }
-    try {
-      const body = req.body;
-      const openaiParams = anthropicMessagesCreateToOpenAI(body);
-      const client = await deps.getOrCreateClient(apiKey);
-      const completion = await client.chat.completions.create(openaiParams);
-      if (body.stream) {
-        res.status(200);
-        res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
-        res.setHeader("Cache-Control", "no-cache");
-        res.setHeader("Connection", "keep-alive");
-        if (completion && typeof completion === "object" && Symbol.asyncIterator in completion) {
-          const messageId = newAnthropicMessageId();
-          await pipeOpenAIChunkStreamToAnthropicSse(res, completion, {
-            anthropicModel: body.model,
-            messageId
-          });
-        } else {
-          sendAnthropicHttpError(res, 500, "api_error", "Expected streamed completion", requestId);
-        }
-        return;
+  async function createTranslation(body) {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
+    try {
+      const sessionId = await attest(apiKey, { model: body.model, enabled: attest2 });
+      const encryptedRequest = await preprocessAudioTranslationRequest(body, encryptionKeys);
+      const response = await fetch(`${endpoints.proxy}/rvenc/audio/translations`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: apiKey,
+          ...sessionId && { "X-Session-Id": sessionId }
+        },
+        body: JSON.stringify(encryptedRequest.body),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        await throwIfErrorResponse(response);
       }
-      const message = openAIChatCompletionToAnthropicMessage(completion, body.model);
-      res.json(message);
-    } catch (err) {
-      if (err instanceof AnthropicRequestValidationError) {
-        return sendAnthropicHttpError(res, err.status, err.anthropicType, err.message, requestId);
+      clearTimeout(timeoutId);
+      return await postprocessTranslationResponse(response, encryptedRequest.sharedSecret);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timed out after ${requestTimeoutMs}ms`);
       }
-      mapUnknownErrorToAnthropicResponse(err, res, requestId);
+      throw error;
     }
-  });
+  }
+  const translationsClient = {
+    create: createTranslation
+  };
+  return {
+    transcriptions: transcriptionsClient,
+    translations: translationsClient
+  };
 }
 
-// src/anthropic/models-route.ts
-function toAnthropicModel(model) {
+// src/files/index.ts
+import { bytesToHex as bytesToHex4, hexToBytes as hexToBytes4, randomBytes as randomBytes3 } from "@noble/ciphers/utils.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { isValid, parseISO } from "date-fns";
+import { z } from "zod";
+
+// src/utils/dek-store.ts
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes3, randomBytes as randomBytes2 } from "@noble/ciphers/utils.js";
+function initializeDEKStore(clientKEK) {
+  const ragDEK = randomBytes2(32);
+  const _clientKEK = clientKEK ? hexToBytes3(clientKEK) : getClientKEK();
+  const wrappedRagDEK = wrapDEK(_clientKEK, ragDEK);
   return {
-    type: "model",
-    id: model.model,
-    display_name: model.name || model.model,
-    created_at: model.created_at
+    fileDEKs: new Map,
+    ragDEK: wrappedRagDEK,
+    ragVersion: "2"
   };
 }
-function filterEnabled(models) {
-  return models.filter((m) => m.enabled !== 0);
-}
-function parseLimit(raw) {
-  if (typeof raw !== "string" || raw.length === 0) {
-    return 20;
+function getClientKEK() {
+  if (!process.env.CLIENT_KEK) {
+    throw new Error("CLIENT_KEK environment variable is not set.");
   }
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n) || n <= 0) {
-    return 20;
+  return hexToBytes3(process.env.CLIENT_KEK);
+}
+function getClientKID(clientKEK) {
+  if (clientKEK) {
+    return bytesToHex3(keyIdFromKEK(hexToBytes3(clientKEK)));
   }
-  return Math.min(n, 1000);
+  const _clientKEK = getClientKEK();
+  return bytesToHex3(keyIdFromKEK(_clientKEK));
 }
-function paginate(all, beforeId, afterId, limit) {
-  let start = 0;
-  let end = all.length;
-  if (afterId) {
-    const idx = all.findIndex((m) => m.id === afterId);
-    if (idx >= 0) {
-      start = idx + 1;
+function generateNewClientKEK() {
+  return bytesToHex3(randomBytes2(32));
+}
+
+// src/files/index.ts
+var MAX_FILENAME_LENGTH = 255;
+var MIN_FILENAME_LENGTH = 1;
+var ALLOWED_MIME_TYPES = new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "application/pdf",
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "text/plain",
+  "text/csv",
+  "text/markdown",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "video/mp4",
+  "video/webm",
+  "video/quicktime",
+  "audio/mpeg",
+  "audio/wav",
+  "audio/ogg",
+  "application/zip",
+  "application/x-rar-compressed",
+  "application/x-7z-compressed",
+  "application/octet-stream"
+]);
+var ApiKeySchema = z.string().trim().min(1, "API key cannot be empty");
+var TimeoutSchema = z.number().int().min(1, "Timeout must be at least 1ms").max(600000, "Timeout must not exceed 600000ms (10 minutes)");
+var DEKStoreSchema = z.object({
+  ragDEK: z.instanceof(Uint8Array).optional(),
+  fileDEKs: z.instanceof(Map).optional()
+});
+var ISO8601DateSchema = z.string().refine((val) => {
+  const date = parseISO(val);
+  return isValid(date);
+}, { message: "Must be a valid ISO8601 date" });
+var MimeTypeSchema = z.string().refine((val) => ALLOWED_MIME_TYPES.has(val), {
+  message: "MIME type is not allowed"
+});
+var FileUploadOptionsSchema = z.object({
+  file: z.instanceof(Uint8Array),
+  fileName: z.string().min(MIN_FILENAME_LENGTH, "File name cannot be empty").max(MAX_FILENAME_LENGTH, `File name cannot exceed ${MAX_FILENAME_LENGTH} characters`).refine((name) => !/[<>:"|?*\x00-\x1F]/.test(name), "Invalid characters").refine((name) => !name.includes("..") && !name.includes("/") && !name.includes("\\"), "No path separators allowed"),
+  mimeType: z.string().optional(),
+  ragIndex: z.boolean().optional()
+});
+var ListFilesOptionsSchema = z.object({
+  limit: z.number().int().positive("Limit must be a positive integer").optional(),
+  offset: z.number().int().nonnegative("Offset must be a non-negative integer").optional(),
+  search: z.string().optional(),
+  from: ISO8601DateSchema.optional(),
+  to: ISO8601DateSchema.optional()
+}).optional();
+var GetFileOptionsSchema = z.object({
+  id: z.string().trim().min(1, "File ID cannot be empty"),
+  url: z.boolean().optional()
+});
+var DeleteFileOptionsSchema = z.object({
+  id: z.string().min(1, "File ID is required")
+});
+var IndexFileInputSchema = z.object({
+  fileId: z.string().min(1, "File ID is required"),
+  filePath: z.string().min(1, "File path is required"),
+  fileDEK: z.instanceof(Uint8Array).optional()
+});
+var IndexFilesOptionsSchema = z.object({
+  files: z.array(IndexFileInputSchema).min(1, "Files array must not be empty"),
+  ragDEK: z.instanceof(Uint8Array).optional()
+});
+var DeleteIndexOptionsSchema = z.object({
+  fileIds: z.array(z.string().min(1)).min(1, "File IDs array must not be empty"),
+  ragDEK: z.instanceof(Uint8Array).optional()
+});
+function validateAPIKey(apiKey) {
+  ApiKeySchema.parse(apiKey);
+}
+function validateDEKStore(dekStore) {
+  DEKStoreSchema.parse(dekStore);
+}
+function validateMimeType(mimeType) {
+  MimeTypeSchema.parse(mimeType);
+}
+function validateFileUploadOptions(options) {
+  FileUploadOptionsSchema.parse(options);
+}
+function validateListFilesOptions(options) {
+  ListFilesOptionsSchema.parse(options);
+}
+function validateGetFileOptions(options) {
+  GetFileOptionsSchema.parse(options);
+}
+function guessMimeType(fileName) {
+  const ext = fileName.toLowerCase().split(".").pop() || "";
+  const mimeTypeMap = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    txt: "text/plain",
+    csv: "text/csv",
+    md: "text/markdown",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    zip: "application/zip",
+    rar: "application/x-rar-compressed",
+    "7z": "application/x-7z-compressed"
+  };
+  return mimeTypeMap[ext] || "application/octet-stream";
+}
+async function saveRagDEKToBackend(apiKey, wrappedRagDEK, timeoutMs) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${endpoints.proxy}/users/save_rag_dek`, {
+      method: "POST",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        data: {
+          wrappedRagDEK,
+          confirmReplaceRagDEK: true
+        }
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to save RAG DEK: HTTP ${response.status}`);
     }
-  }
-  if (beforeId) {
-    const idx = all.findIndex((m) => m.id === beforeId);
-    if (idx >= 0) {
-      end = idx;
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Save RAG DEK request timed out after ${timeoutMs}ms`);
     }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function prepareEncryptedPayload(dekStore, options, apiKey, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  const fileBytes = options.file;
+  const mimeType = options.mimeType || guessMimeType(options.fileName);
+  validateMimeType(mimeType);
+  const dek = randomBytes3(32);
+  const encryptedFile = encryptWithDEK(dek, fileBytes);
+  const encryptedName = encryptMetadataWithDEK(dek, options.fileName);
+  const encryptedMimeType = encryptMetadataWithDEK(dek, mimeType);
+  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
+  const wrappedDEK = wrapDEK(_clientKEK, dek);
+  const clientKID = clientKEK ? getClientKID(clientKEK) : getClientKID();
+  const filePayload = {
+    client_hash: bytesToHex4(sha2562(fileBytes)),
+    encrypted_content: bytesToHex4(encryptedFile),
+    encrypted_name: encryptedName,
+    kid: clientKID,
+    mime_type: encryptedMimeType,
+    version: "2",
+    wrapped_dek: bytesToHex4(wrappedDEK)
+  };
+  if (options.ragIndex) {
+    await addRagIndexToPayload(dekStore, dek, filePayload, apiKey, clientKEK, timeoutMs);
   }
-  const window = all.slice(start, end);
-  const items = window.slice(0, limit);
-  return { items, hasMore: window.length > items.length };
+  return { dek, filePayload };
 }
-function registerAnthropicModelsRoute(router, deps) {
-  router.get("/v1/models", async (req, res) => {
-    const requestId = newAnthropicRequestId();
-    res.setHeader("request-id", requestId);
-    const versionResult = resolveAnthropicVersion(req);
-    if (!versionResult.ok) {
-      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
-    }
-    const apiKey = extractAnthropicApiKey(req);
-    if (!apiKey) {
-      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
-    }
+async function addRagIndexToPayload(dekStore, dek, filePayload, apiKey, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  let ragDEK = dekStore.ragDEK;
+  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
+  if (!ragDEK) {
+    ragDEK = randomBytes3(32);
+    const wrappedRagDEK = wrapDEK(_clientKEK, ragDEK);
+    dekStore.ragDEK = wrappedRagDEK;
     try {
-      const client = await deps.getOrCreateClient(apiKey);
-      const type = typeof req.query.type === "string" ? req.query.type : undefined;
-      const all = filterEnabled(await client.models.list({ type })).map(toAnthropicModel);
-      const beforeId = typeof req.query.before_id === "string" ? req.query.before_id : undefined;
-      const afterId = typeof req.query.after_id === "string" ? req.query.after_id : undefined;
-      const limit = parseLimit(req.query.limit);
-      const { items, hasMore } = paginate(all, beforeId, afterId, limit);
-      res.json({
-        data: items,
-        first_id: items.length > 0 ? items[0].id : null,
-        last_id: items.length > 0 ? items[items.length - 1].id : null,
-        has_more: hasMore
-      });
-    } catch (err) {
-      mapUnknownErrorToAnthropicResponse(err, res, requestId);
+      await saveRagDEKToBackend(apiKey, bytesToHex4(wrappedRagDEK), timeoutMs);
+    } catch (error) {
+      console.error("Warning: Failed to save RAG DEK to backend:", error);
     }
+  } else {
+    ragDEK = unwrapDEK(_clientKEK, ragDEK);
+  }
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const { encrypted: encryptedFileDEK, nonce: fileNonce } = encryptPayload(sharedSecret, dek);
+  const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
+  filePayload.encrypted_file_dek = bytesToHex4(encryptedFileDEK);
+  filePayload.encrypted_rag_dek = bytesToHex4(encryptedRagDEK);
+  filePayload.file_nonce = bytesToHex4(fileNonce);
+  filePayload.rag_dek_nonce = bytesToHex4(ragDEKNonce);
+  filePayload.cipher_text = bytesToHex4(cipherText);
+}
+async function performUpload(apiKey, filePayload, controller) {
+  const uploadResponse = await fetch(`${endpoints.proxy}/files/encrypted/upload`, {
+    method: "POST",
+    headers: {
+      Authorization: apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(filePayload),
+    signal: controller.signal
   });
-  router.get("/v1/models/:model_id", async (req, res) => {
-    const requestId = newAnthropicRequestId();
-    res.setHeader("request-id", requestId);
-    const versionResult = resolveAnthropicVersion(req);
-    if (!versionResult.ok) {
-      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
-    }
-    const apiKey = extractAnthropicApiKey(req);
-    if (!apiKey) {
-      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
-    }
-    const modelId = req.params.model_id;
-    if (!modelId) {
-      return sendAnthropicHttpError(res, 400, "invalid_request_error", "Missing model id.", requestId);
-    }
+  if (!uploadResponse.ok) {
+    let errorMessage = `Upload request failed with status ${uploadResponse.status}`;
     try {
-      const client = await deps.getOrCreateClient(apiKey);
-      const found = filterEnabled(await client.models.list()).find((m) => m.model === modelId);
-      if (!found) {
-        return sendAnthropicHttpError(res, 404, "not_found_error", `Model "${modelId}" not found.`, requestId);
+      const body = await uploadResponse.json();
+      if (body.error) {
+        errorMessage = body.error;
       }
-      res.json(toAnthropicModel(found));
-    } catch (err) {
-      mapUnknownErrorToAnthropicResponse(err, res, requestId);
-    }
-  });
-}
-
-// src/server/runtime.ts
-import multer from "multer";
-
-// src/audio/index.ts
-import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes2 } from "@noble/ciphers/utils.js";
-
-// src/config.ts
-var endpoints = {
-  enclave: process.env.ENCLAVE_URL,
-  proxy: process.env.PROXY_URL
-};
-var DEFAULT_REQUEST_TIMEOUT_MS = 600000;
-var DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
-
-// src/utils/attestation.ts
-var cachedPrem;
-async function loadPrem() {
-  if (cachedPrem)
-    return cachedPrem;
-  const isBare = typeof globalThis.Bare !== "undefined";
-  if (isBare) {
-    cachedPrem = await (async (s, y) => await import(s, y))("@premai/reticle", { with: { type: "script" } });
-    return cachedPrem;
+    } catch {}
+    throw new Error(errorMessage);
   }
-  cachedPrem = await import("@premai/reticle");
-  return cachedPrem;
-}
-function isAttestationError(err) {
-  return err instanceof Error && err.name === "AttestationError";
+  const uploadResult = await uploadResponse.json();
+  if (uploadResult.status !== 200) {
+    throw new Error(uploadResult.error || "Upload failed");
+  }
+  if (!uploadResult.data) {
+    throw new Error("Upload response missing data");
+  }
+  return uploadResult.data;
 }
-var ATTEST_TTL_MS = 30000;
-var ATTEST_CACHE_MAX = 500;
-var ATTEST_MAX_ATTEMPTS = 4;
-var ATTEST_RETRY_BASE_MS = 250;
-var ATTEST_RETRY_MAX_MS = 2000;
-var TRANSIENT_PATTERNS = [
-  /EOF while parsing/i,
-  /error decoding response body/i,
-  /connection (reset|closed|refused)/i,
-  /socket hang up/i,
-  /ETIMEDOUT/i
-];
-var attestCache = new Map;
-var attestInflight = new Map;
-function attestCacheKey(apiKey, model) {
-  return `${apiKey}|${model ?? ""}`;
+function storeDEKForFile(dekStore, fileId, dek, clientKEK) {
+  if (!dekStore.fileDEKs) {
+    dekStore.fileDEKs = new Map;
+  }
+  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
+  const wrappedDEK = wrapDEK(_clientKEK, dek);
+  dekStore.fileDEKs.set(fileId, wrappedDEK);
 }
-function pruneExpired(now) {
-  for (const [key, entry] of attestCache) {
-    if (entry.expires <= now) {
-      attestCache.delete(key);
-    } else {
-      break;
+async function uploadFile(apiKey, dekStore, options, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  validateAPIKey(apiKey);
+  validateDEKStore(dekStore);
+  validateFileUploadOptions(options);
+  TimeoutSchema.parse(timeoutMs);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const { dek, filePayload } = await prepareEncryptedPayload(dekStore, options, apiKey, clientKEK, timeoutMs);
+    const uploadedFile = await performUpload(apiKey, filePayload, controller);
+    storeDEKForFile(dekStore, uploadedFile.id, dek, clientKEK);
+    return uploadedFile;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`File upload timed out after ${timeoutMs}ms`);
     }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
   }
 }
-function isTransientError(err) {
-  const messages = [];
-  if (err instanceof Error) {
-    messages.push(err.message);
+async function listFiles(apiKey, options, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  validateAPIKey(apiKey);
+  validateListFilesOptions(options);
+  TimeoutSchema.parse(timeoutMs);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  const queryParams = new URLSearchParams;
+  if (options?.limit !== undefined) {
+    queryParams.append("limit", options.limit.toString());
   }
-  if (isAttestationError(err) && Array.isArray(err.cause)) {
-    messages.push(...err.cause);
+  if (options?.offset !== undefined) {
+    queryParams.append("offset", options.offset.toString());
   }
-  return messages.some((m) => TRANSIENT_PATTERNS.some((re) => re.test(m)));
-}
-function backoffDelayMs(attempt) {
-  const exp = ATTEST_RETRY_BASE_MS * 2 ** (attempt - 1);
-  const capped = Math.min(exp, ATTEST_RETRY_MAX_MS);
-  const jitter = Math.floor(Math.random() * (capped / 2));
-  return capped + jitter;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function safeFree(obj) {
-  if (typeof obj?.free !== "function")
-    return;
+  if (options?.search) {
+    queryParams.append("search", options.search);
+  }
+  if (options?.from) {
+    queryParams.append("from", options.from);
+  }
+  if (options?.to) {
+    queryParams.append("to", options.to);
+  }
+  const queryString = queryParams.toString();
+  const url = `${endpoints.proxy}/files/encrypted${queryString ? `?${queryString}` : ""}`;
   try {
-    obj.free();
-  } catch {}
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`List files request failed with status ${response.status}`);
+    }
+    const result = await response.json();
+    if (result.status !== 200) {
+      throw new Error(result.error || "List files failed");
+    }
+    if (!result.data) {
+      throw new Error("List files response missing data");
+    }
+    return result.data;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`List files request timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
 }
-async function attemptAttest(apiKey, options) {
-  const prem = await loadPrem();
-  let client;
-  let attested;
-  let headers;
-  let sessionId;
+async function getFile(apiKey, options, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  validateAPIKey(apiKey);
+  validateGetFileOptions(options);
+  TimeoutSchema.parse(timeoutMs);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  const queryParams = new URLSearchParams;
+  if (options.url !== undefined) {
+    queryParams.append("url", options.url ? "true" : "false");
+  }
+  const queryString = queryParams.toString();
+  const url = `${endpoints.proxy}/files/encrypted/${options.id}${queryString ? `?${queryString}` : ""}`;
   try {
-    client = await new prem.ClientBuilder(endpoints.proxy ?? "").with_authorization(apiKey).build();
-    if (options.model) {
-      client.set_query(new prem.QueryParams().with("model", options.model));
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`File not found: ${options.id}`);
+      }
+      throw new Error(`Get file request failed with status ${response.status}`);
     }
-    attested = await client.attest();
-    headers = attested.headers();
-    sessionId = headers.cpu()?.get("x-session-id") ?? headers.gpu()?.get("x-session-id") ?? null;
+    const result = await response.json();
+    if (result.status !== 200) {
+      throw new Error(result.error || "Get file failed");
+    }
+    if (!result.data) {
+      throw new Error("Get file response missing data");
+    }
+    return result.data;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Get file request timed out after ${timeoutMs}ms`);
+    }
+    throw error;
   } finally {
-    safeFree(headers);
-    safeFree(attested);
-    safeFree(client);
-  }
-  if (sessionId === null) {
-    throw new Error("missing x-session-id issued by attestation");
+    clearTimeout(timeoutId);
   }
-  return sessionId;
 }
-async function runAttest(apiKey, options) {
-  let lastErr;
-  for (let attempt = 1;attempt <= ATTEST_MAX_ATTEMPTS; attempt++) {
-    try {
-      return await attemptAttest(apiKey, options);
-    } catch (err) {
-      lastErr = err;
-      if (attempt === ATTEST_MAX_ATTEMPTS || !isTransientError(err)) {
-        throw err;
+async function deleteFile(apiKey, options, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  validateAPIKey(apiKey);
+  DeleteFileOptionsSchema.parse(options);
+  TimeoutSchema.parse(timeoutMs);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${endpoints.proxy}/files/encrypted/${options.id}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`File not found: ${options.id}`);
       }
-      await delay(backoffDelayMs(attempt));
+      throw new Error(`Delete file request failed with status ${response.status}`);
+    }
+    await response.json();
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Delete file request timed out after ${timeoutMs}ms`);
     }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
   }
-  throw lastErr;
 }
-async function attest(apiKey, options = { enabled: true }) {
-  if (!options.enabled)
-    return null;
-  const key = attestCacheKey(apiKey, options.model);
-  const now = Date.now();
-  const cached = attestCache.get(key);
-  if (cached) {
-    if (cached.expires > now)
-      return cached.sessionId;
-    attestCache.delete(key);
-  }
-  const inflight = attestInflight.get(key);
-  if (inflight) {
-    return inflight;
+async function indexFiles(apiKey, dekStore, options, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  validateAPIKey(apiKey);
+  validateDEKStore(dekStore);
+  IndexFilesOptionsSchema.parse(options);
+  TimeoutSchema.parse(timeoutMs);
+  const wrappedRagDEK = options.ragDEK || dekStore.ragDEK;
+  if (!wrappedRagDEK) {
+    throw new Error("RAG DEK not found. Provide ragDEK in options or upload at least one file with ragIndex: true.");
   }
-  const work = runAttest(apiKey, options).then((sessionId) => {
-    const insertTime = Date.now();
-    pruneExpired(insertTime);
-    attestCache.set(key, { sessionId, expires: insertTime + ATTEST_TTL_MS });
-    if (attestCache.size > ATTEST_CACHE_MAX) {
-      const oldest = attestCache.keys().next().value;
-      if (oldest)
-        attestCache.delete(oldest);
+  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
+  const ragDEK = unwrapDEK(_clientKEK, wrappedRagDEK);
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const encryptedFiles = options.files.map((file) => {
+    const wrappedFileDEK = file.fileDEK || dekStore.fileDEKs?.get(file.fileId);
+    if (!wrappedFileDEK) {
+      throw new Error(`File DEK not found for file: ${file.fileId}. Provide fileDEK or ensure file was uploaded with this DEK store.`);
     }
-    return sessionId;
-  }).finally(() => {
-    attestInflight.delete(key);
+    const fileDEK = unwrapDEK(_clientKEK, wrappedFileDEK);
+    const { encrypted: encryptedFileDEK, nonce: fileNonce } = encryptPayload(sharedSecret, fileDEK);
+    const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
+    return {
+      file_id: file.fileId,
+      encrypted_file_dek: bytesToHex4(encryptedFileDEK),
+      encrypted_rag_dek: bytesToHex4(encryptedRagDEK),
+      file_nonce: bytesToHex4(fileNonce),
+      rag_dek_nonce: bytesToHex4(ragDEKNonce),
+      s3_r2_path: file.filePath,
+      cipher_text: bytesToHex4(cipherText)
+    };
   });
-  attestInflight.set(key, work);
-  return work;
-}
-
-// src/utils/crypto.ts
-import { aeskwp } from "@noble/ciphers/aes.js";
-import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
-import { bytesToHex as bytesToHex2, hexToBytes, managedNonce, randomBytes as randomBytes2 } from "@noble/ciphers/utils.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import { sha3_256 } from "@noble/hashes/sha3.js";
-import { XWing } from "@noble/post-quantum/hybrid.js";
-function createMLKEMEncapsulation(publicKeyHex) {
-  return XWing.encapsulate(hexToBytes(publicKeyHex));
-}
-function encryptPayload(sharedSecret, data) {
-  const nonce = randomBytes2(24);
-  const chacha = xchacha20poly1305(sharedSecret, nonce);
-  let encodedData;
-  if (data instanceof Uint8Array) {
-    encodedData = data;
-  } else if (typeof data === "string") {
-    encodedData = new TextEncoder().encode(data);
-  } else {
-    encodedData = new TextEncoder().encode(JSON.stringify(data));
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${endpoints.proxy}/files/encrypted/index`, {
+      method: "POST",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ files: encryptedFiles }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Index files request failed with status ${response.status}`);
+    }
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Index files request timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
   }
-  const encrypted = chacha.encrypt(encodedData);
-  return { encrypted, nonce };
 }
-function decryptPayload(encryptedData, sharedSecret, nonce) {
-  const chacha = xchacha20poly1305(sharedSecret, nonce);
-  const encrypted = hexToBytes(encryptedData);
-  const decrypted = chacha.decrypt(encrypted);
-  const str = new TextDecoder().decode(decrypted);
+async function deleteIndex(apiKey, dekStore, options, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  validateAPIKey(apiKey);
+  validateDEKStore(dekStore);
+  DeleteIndexOptionsSchema.parse(options);
+  TimeoutSchema.parse(timeoutMs);
+  const wrappedRagDEK = options.ragDEK || dekStore.ragDEK;
+  if (!wrappedRagDEK) {
+    throw new Error("RAG DEK not found. Provide ragDEK in options or ensure dekStore has a ragDEK.");
+  }
+  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
+  const ragDEK = unwrapDEK(_clientKEK, wrappedRagDEK);
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    return JSON.parse(str);
-  } catch {
-    return str;
+    const response = await fetch(`${endpoints.proxy}/files/encrypted/delete-index`, {
+      method: "POST",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        cipher_text: bytesToHex4(cipherText),
+        encrypted_rag_dek: bytesToHex4(encryptedRagDEK),
+        rag_dek_nonce: bytesToHex4(ragDEKNonce),
+        fileIds: options.fileIds
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Delete index request failed with status ${response.status}`);
+    }
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Delete index request timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
   }
 }
-async function getEnclavePublicKey(timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+function createFilesClient(apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  return {
+    upload: (options) => uploadFile(apiKey, dekStore, options, clientKEK, timeoutMs),
+    list: (options) => listFiles(apiKey, options, timeoutMs),
+    get: (options) => getFile(apiKey, options, timeoutMs),
+    delete: (options) => deleteFile(apiKey, options, timeoutMs),
+    index: (options) => indexFiles(apiKey, dekStore, options, clientKEK, timeoutMs),
+    deleteIndex: (options) => deleteIndex(apiKey, dekStore, options, clientKEK, timeoutMs)
+  };
+}
+
+// src/models/index.ts
+async function listModels(params, apiKey, timeoutMs) {
   const controller = new AbortController;
   const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  const queryParams = new URLSearchParams;
+  if (params?.type !== undefined) {
+    queryParams.append("type", params.type);
+  }
+  const queryString = queryParams.toString();
+  const url = `${endpoints.proxy}/models${queryString ? `?${queryString}` : ""}`;
   try {
-    const response = await fetch(`${endpoints.enclave}/publicKey`, {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: apiKey,
+        "Content-Type": "application/json"
+      },
       signal: controller.signal
     });
     if (!response.ok) {
-      throw new Error(`Failed to fetch enclave public key: ${response.status} ${response.statusText}`);
+      throw new Error(`List models request failed with status ${response.status}`);
     }
-    const data = await response.json();
-    if (!data.publicKey || typeof data.publicKey !== "string") {
-      throw new Error("Invalid public key response from enclave");
+    const result = await response.json();
+    if (result.status !== 200) {
+      throw new Error(result.error || "List models failed");
     }
-    return data.publicKey;
+    if (!result.data) {
+      throw new Error("List models response missing data");
+    }
+    return result.data;
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Enclave public key request timed out after ${timeoutMs}ms`);
+      throw new Error(`List models request timed out after ${timeoutMs}ms`);
     }
-    throw new Error(`Failed to get enclave public key: ${error instanceof Error ? error.message : error}`);
+    throw error;
   } finally {
     clearTimeout(timeoutId);
   }
 }
-async function generateEncryptionKeys(timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  return createMLKEMEncapsulation(enclavePublicKey);
+function createModelsClient(apiKey, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  return {
+    list: (params) => listModels(params, apiKey, timeoutMs)
+  };
 }
-function keyIdFromKEK(kek, context = "kek:v1", length = 16) {
-  const ctx = new TextEncoder().encode(context);
-  const input = new Uint8Array(kek.length + ctx.length);
-  input.set(kek, 0);
-  input.set(ctx, kek.length);
-  const digest = sha256(input);
-  return digest.slice(0, length);
+
+// src/rvenc/index.ts
+import { bytesToHex as bytesToHex5, hexToBytes as hexToBytes5 } from "@noble/ciphers/utils.js";
+import OpenAI from "openai";
+function preprocessRequest(body, encryptionKeys) {
+  const { cipherText, sharedSecret } = encryptionKeys;
+  const { encrypted, nonce } = encryptPayload(sharedSecret, body);
+  return {
+    body: {
+      cipherText: bytesToHex5(cipherText),
+      encryptedInference: bytesToHex5(encrypted),
+      nonce: bytesToHex5(nonce),
+      model: body.model,
+      stream: body.stream === true
+    },
+    sharedSecret,
+    nonce
+  };
 }
-function encryptWithDEK(dek, plaintext) {
-  const aead = managedNonce(xchacha20poly1305)(dek);
-  return aead.encrypt(plaintext);
+async function postprocessStreamingResponse(response, sharedSecret, nonce, maxBufferSize) {
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  const reader = response.body.getReader();
+  const generator = createDecryptedStreamGenerator(reader, sharedSecret, nonce, maxBufferSize);
+  return {
+    [Symbol.asyncIterator]() {
+      return generator;
+    }
+  };
 }
-function encryptMetadataWithDEK(dek, metadata) {
-  const encoded = new TextEncoder().encode(metadata);
-  const encrypted = encryptWithDEK(dek, encoded);
-  return bytesToHex2(encrypted);
+async function postprocessNonStreamingResponse(response, sharedSecret) {
+  const data = await response.json();
+  if (!data.encryptedResponse || !data.nonce) {
+    throw new Error("Invalid non-streaming response: missing encryptedResponse or nonce");
+  }
+  const responseNonce = hexToBytes5(data.nonce);
+  return decryptPayload(data.encryptedResponse, sharedSecret, responseNonce);
 }
-function wrapDEK(kek, dek) {
-  const kw = aeskwp(kek);
-  return kw.encrypt(dek);
+function createRvencChatClient(apiKey, encryptionKeys, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, maxBufferSize = DEFAULT_MAX_BUFFER_SIZE, attest2 = true, OpenAIClientParams) {
+  const client = new OpenAI({ apiKey: "not-used", ...OpenAIClientParams });
+  const originalChatCreate = client.chat.completions.create.bind(client.chat.completions);
+  client.chat.completions.create = async (body) => {
+    const isStreaming = body.stream === true;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
+    try {
+      const sessionId = await attest(apiKey, { model: body.model, enabled: attest2 });
+      const encryptedRequest = preprocessRequest(body, encryptionKeys);
+      const response = await fetch(`${endpoints.proxy}/rvenc/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: isStreaming ? "text/event-stream" : "application/json",
+          Authorization: apiKey,
+          ...sessionId && { "X-Session-Id": sessionId }
+        },
+        body: JSON.stringify(encryptedRequest.body),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        await throwIfErrorResponse(response);
+      }
+      clearTimeout(timeoutId);
+      if (isStreaming) {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("text/event-stream")) {
+          return await postprocessStreamingResponse(response, encryptedRequest.sharedSecret, encryptedRequest.nonce, maxBufferSize);
+        }
+        const completion = await postprocessNonStreamingResponse(response, encryptedRequest.sharedSecret);
+        return completionToChunkStream(completion);
+      }
+      return await postprocessNonStreamingResponse(response, encryptedRequest.sharedSecret);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timed out after ${requestTimeoutMs}ms`);
+      }
+      throw error;
+    }
+  };
+  return client;
 }
-function unwrapDEK(kek, wrappedDEK) {
-  const kw = aeskwp(kek);
-  return kw.decrypt(wrappedDEK);
+async function* completionToChunkStream(completion) {
+  const choice = completion.choices[0];
+  const message = choice?.message;
+  const content = typeof message?.content === "string" ? message.content : "";
+  const toolCalls = message?.tool_calls?.filter((tc) => tc.type === "function").map((tc, i) => ({
+    index: i,
+    id: tc.id,
+    type: "function",
+    function: {
+      name: tc.function.name,
+      arguments: tc.function.arguments
+    }
+  }));
+  yield {
+    id: completion.id,
+    object: "chat.completion.chunk",
+    created: completion.created,
+    model: completion.model,
+    choices: [
+      {
+        index: choice?.index ?? 0,
+        delta: {
+          role: "assistant",
+          content,
+          ...toolCalls && toolCalls.length > 0 && { tool_calls: toolCalls }
+        },
+        finish_reason: choice?.finish_reason ?? "stop",
+        logprobs: null
+      }
+    ],
+    usage: completion.usage ?? null
+  };
 }
-function decryptWithDEK(dek, encryptedContent) {
-  const aead = managedNonce(xchacha20poly1305)(dek);
-  return aead.decrypt(encryptedContent);
+async function* createDecryptedStreamGenerator(reader, sharedSecret, nonce, maxBufferSize) {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      if (buffer.length > maxBufferSize) {
+        throw new Error(`Stream buffer exceeded maximum size of ${maxBufferSize} bytes`);
+      }
+      const parts = buffer.split(`
+
+`);
+      for (let i = 0;i < parts.length - 1; i++) {
+        const part = parts[i];
+        const lines = part.split(`
+`);
+        let event;
+        let data;
+        if (lines[0]) {
+          const eventSplit = lines[0].split(": ");
+          event = eventSplit[1];
+        }
+        if (lines[1]) {
+          const dataSplit = lines[1].split(": ");
+          data = dataSplit.slice(1).join(": ");
+        }
+        if (event === "done" && data === "[DONE]") {
+          return;
+        }
+        if (event === "error") {
+          const errorObj = JSON.parse(data || "{}");
+          throw new Error(errorObj.error?.message || data || "Stream error");
+        }
+        if (event === "data" && data && data !== "[DONE]") {
+          const chunk = decryptPayload(data, sharedSecret, nonce);
+          if (chunk.error) {
+            throw new Error(chunk.error.message || "Stream error");
+          }
+          yield chunk;
+        }
+      }
+      buffer = parts[parts.length - 1];
+    }
+  } finally {
+    reader.releaseLock();
+  }
 }
 
-// src/utils/error.ts
-async function throwIfErrorResponse(response) {
-  let raw;
+// src/tools/index.ts
+import { bytesToHex as bytesToHex6, hexToBytes as hexToBytes6, randomBytes as randomBytes4 } from "@noble/ciphers/utils.js";
+var FILE_OUTPUT_TOOLS = ["generateImage", "audioGenerateFromText", "createFileForUser"];
+var FILE_INPUT_TOOLS = [
+  "imageDescribeAndCaption",
+  "imageDescribeAndCaptionFallback",
+  "videoDescribeAndCaption",
+  "getPDFContent",
+  "getTextDocumentContent",
+  "transcribeAudioToText",
+  "transcribeAudioWithDiarization",
+  "audioDiarization",
+  "getSpreadsheetContent",
+  "getPowerPointContent",
+  "getDataFileContent",
+  "getFileContentOCR"
+];
+var RAG_TOOLS = ["searchRag"];
+async function callToolRequest(toolName, body, apiKey, timeoutMs, attest2) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    raw = await response.json();
-    if (!raw.status)
-      raw = { ...raw, status: response.status };
-  } catch {
-    raw = {
-      status: response.status,
-      data: null,
-      error: response.statusText || `HTTP ${response.status}`,
-      message: null
-    };
+    const response = await fetch(`${endpoints.proxy}/tools/${toolName}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: apiKey
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      await throwIfErrorResponse(response);
+    }
+    const data = await response.json();
+    return data.data;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Tool request timed out after ${timeoutMs}ms`);
+    }
+    throw new Error(`Tool request failed: ${error instanceof Error ? error.message : error}`);
   }
-  throw raw;
 }
-
-// src/utils/files.ts
-var getFileName = (file) => {
-  if (file instanceof File) {
-    return file.name;
-  }
-  if (file instanceof Blob) {
-    return;
-  }
-  const fileAny = file;
-  if (fileAny.path) {
-    const path = typeof fileAny.path === "string" ? fileAny.path : fileAny.path.toString();
-    return path.split("/").pop() || path.split("\\").pop() || path;
-  }
-  if (file instanceof Uint8Array || file instanceof ArrayBuffer) {
-    return;
-  }
-  return;
-};
-
-// src/audio/index.ts
-async function readUploadableToUint8Array(file) {
-  if (file instanceof Uint8Array) {
-    return file;
-  }
-  if (file instanceof ArrayBuffer) {
-    return new Uint8Array(file);
-  }
-  if (typeof file.arrayBuffer === "function") {
-    const blob = file;
-    const buffer = await blob.arrayBuffer();
-    return new Uint8Array(buffer);
-  }
-  const fileAny = file;
-  if (typeof fileAny.on === "function" && (typeof fileAny.read === "function" || typeof fileAny.pipe === "function")) {
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-      fileAny.on("data", (chunk) => {
-        if (Buffer.isBuffer(chunk)) {
-          chunks.push(new Uint8Array(chunk));
-        } else if (chunk instanceof Uint8Array) {
-          chunks.push(chunk);
-        } else if (typeof chunk === "object" && chunk !== null) {
-          chunks.push(new Uint8Array(Buffer.from(chunk)));
-        }
-      });
-      fileAny.on("end", () => {
-        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-        const result = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of chunks) {
-          result.set(chunk, offset);
-          offset += chunk.length;
-        }
-        resolve(result);
-      });
-      fileAny.on("error", (err) => reject(err));
+async function downloadEncryptedFile(fileId, apiKey, timeoutMs) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const metadataResponse = await fetch(`${endpoints.proxy}/files/encrypted/${fileId}?url=true`, {
+      headers: { Authorization: apiKey },
+      signal: controller.signal
     });
+    if (!metadataResponse.ok) {
+      throw new Error(`Failed to get file metadata: ${metadataResponse.status}`);
+    }
+    const metadata = await metadataResponse.json();
+    const downloadUrl = metadata.data?.url;
+    if (!downloadUrl) {
+      throw new Error("No download URL in response");
+    }
+    const fileResponse = await fetch(downloadUrl, { signal: controller.signal });
+    if (!fileResponse.ok) {
+      throw new Error(`Failed to download file: ${fileResponse.status}`);
+    }
+    clearTimeout(timeoutId);
+    const arrayBuffer = await fileResponse.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`File download timed out after ${timeoutMs}ms`);
+    }
+    throw error;
   }
-  throw new Error("Unsupported file type for audio transcription");
 }
-async function preprocessAudioRequest(body, encryptionKeys) {
-  const { cipherText, sharedSecret } = encryptionKeys;
-  const audioData = await readUploadableToUint8Array(body.file);
-  const isDeepgram = body.model.startsWith("deepgram/");
-  const requestBody = isDeepgram ? {
-    model: body.model,
-    diarize: body.diarize,
-    smart_format: body.smart_format
-  } : {
-    model: body.model,
-    language: body.language,
-    prompt: body.prompt,
-    response_format: body.response_format,
-    temperature: body.temperature,
-    timestamp_granularities: body.timestamp_granularities
+async function downloadAndDecryptFile(response, dek, apiKey, timeoutMs) {
+  if (!response.success || !response.fileId) {
+    return null;
+  }
+  const decryptFileName = (encryptedHex) => {
+    const encrypted = hexToBytes6(encryptedHex);
+    const decrypted = decryptWithDEK(dek, encrypted);
+    return new TextDecoder().decode(decrypted);
   };
-  const cleanedBody = Object.fromEntries(Object.entries(requestBody).filter(([_, v]) => v !== undefined));
-  const { encrypted, nonce } = encryptPayload(sharedSecret, cleanedBody);
-  const { encrypted: encryptedFile, nonce: fileNonce } = encryptPayload(sharedSecret, audioData);
-  const fileName = getFileName(body.file) || "audio.mp3";
-  const { encrypted: encryptedFileName, nonce: fileNameNonce } = encryptPayload(sharedSecret, fileName);
+  const fileName = decryptFileName(response.fileName);
+  const mimeType = decryptFileName(response.mimeType);
+  const encryptedFile = await downloadEncryptedFile(response.fileId, apiKey, timeoutMs);
+  const decryptedFile = decryptWithDEK(dek, encryptedFile);
   return {
-    body: {
-      cipherText: bytesToHex3(cipherText),
-      encryptedInference: bytesToHex3(encrypted),
-      nonce: bytesToHex3(nonce),
-      fileNameNonce: bytesToHex3(fileNameNonce),
-      encryptedFileName: bytesToHex3(encryptedFileName),
-      fileNonce: bytesToHex3(fileNonce),
-      encryptedFile: bytesToHex3(encryptedFile),
-      model: body.model
-    },
-    sharedSecret
+    fileId: response.fileId,
+    fileName,
+    mimeType,
+    content: decryptedFile,
+    fileSize: decryptedFile.length
   };
 }
-async function postprocessTranscriptionResponse(response, sharedSecret) {
-  const responseData = await response.json();
-  const data = responseData.data;
-  if (!data.encryptedResponse || !data.nonce) {
-    throw new Error("Invalid transcription response: missing encryptedResponse or nonce");
-  }
-  const responseNonce = hexToBytes2(data.nonce);
-  return decryptPayload(data.encryptedResponse, sharedSecret, responseNonce);
+async function callSimpleTool(toolName, params, apiKey, timeoutMs, attest2) {
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const { encrypted, nonce } = encryptPayload(sharedSecret, params);
+  const body = {
+    cipherText: bytesToHex6(cipherText),
+    encryptedParams: bytesToHex6(encrypted),
+    nonce: bytesToHex6(nonce)
+  };
+  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
+  return decryptPayload(response.encryptedResponse, sharedSecret, hexToBytes6(response.nonce));
 }
-async function postprocessTranslationResponse(response, sharedSecret) {
-  const responseData = await response.json();
-  const data = responseData.data;
-  if (!data.encryptedResponse || !data.nonce) {
-    throw new Error("Invalid translation response: missing encryptedResponse or nonce");
+async function callFileOutputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const { encrypted, nonce } = encryptPayload(sharedSecret, params);
+  const dek = randomBytes4(32);
+  const { encrypted: encryptedDEK, nonce: dekNonce } = encryptPayload(sharedSecret, dek);
+  const _clientKEK = clientKEK ? hexToBytes6(clientKEK) : getClientKEK();
+  const wrappedDEK = wrapDEK(_clientKEK, dek);
+  const clientKID = clientKEK ? getClientKID(clientKEK) : getClientKID();
+  const body = {
+    cipherText: bytesToHex6(cipherText),
+    encryptedParams: bytesToHex6(encrypted),
+    nonce: bytesToHex6(nonce),
+    encryptedDEK: bytesToHex6(encryptedDEK),
+    dekNonce: bytesToHex6(dekNonce),
+    kid: clientKID,
+    wrappedDEK: bytesToHex6(wrappedDEK)
+  };
+  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
+  const result = await downloadAndDecryptFile(response, dek, apiKey, timeoutMs);
+  if (result?.fileId) {
+    if (!dekStore.fileDEKs) {
+      dekStore.fileDEKs = new Map;
+    }
+    dekStore.fileDEKs.set(result.fileId, wrappedDEK);
   }
-  const responseNonce = hexToBytes2(data.nonce);
-  return decryptPayload(data.encryptedResponse, sharedSecret, responseNonce);
+  return result;
 }
-async function preprocessAudioTranslationRequest(body, encryptionKeys) {
-  const { cipherText, sharedSecret } = encryptionKeys;
-  const audioData = await readUploadableToUint8Array(body.file);
-  const requestBody = {
-    model: body.model,
-    prompt: body.prompt,
-    response_format: body.response_format,
-    temperature: body.temperature
-  };
-  const cleanedBody = Object.fromEntries(Object.entries(requestBody).filter(([_, v]) => v !== undefined));
-  const { encrypted, nonce } = encryptPayload(sharedSecret, cleanedBody);
-  const { encrypted: encryptedFile, nonce: fileNonce } = encryptPayload(sharedSecret, audioData);
-  const fileName = getFileName(body.file) || "audio.mp3";
-  const { encrypted: encryptedFileName, nonce: fileNameNonce } = encryptPayload(sharedSecret, fileName);
-  return {
-    body: {
-      cipherText: bytesToHex3(cipherText),
-      encryptedInference: bytesToHex3(encrypted),
-      nonce: bytesToHex3(nonce),
-      fileNameNonce: bytesToHex3(fileNameNonce),
-      encryptedFileName: bytesToHex3(encryptedFileName),
-      fileNonce: bytesToHex3(fileNonce),
-      encryptedFile: bytesToHex3(encryptedFile),
-      model: body.model
-    },
-    sharedSecret
+async function callFileInputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
+  if (!params.fileId) {
+    throw new Error(`Tool ${toolName} requires fileId parameter`);
+  }
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const dek = randomBytes4(32);
+  const { encrypted: encryptedDEK, nonce: dekNonce } = encryptPayload(sharedSecret, dek);
+  const nonce = randomBytes4(24);
+  if (!dekStore.fileDEKs) {
+    dekStore.fileDEKs = new Map;
+  }
+  const _clientKEK = clientKEK ? hexToBytes6(clientKEK) : getClientKEK();
+  let fileDEK = dekStore.fileDEKs.get(params.fileId);
+  if (!fileDEK) {
+    fileDEK = randomBytes4(32);
+    const wrappedFileDEK = wrapDEK(_clientKEK, fileDEK);
+    dekStore.fileDEKs.set(params.fileId, wrappedFileDEK);
+  } else {
+    fileDEK = unwrapDEK(_clientKEK, fileDEK);
+  }
+  const { encrypted: encryptedFileDEK, nonce: fileDEKNonce } = encryptPayload(sharedSecret, fileDEK);
+  const body = {
+    cipherText: bytesToHex6(cipherText),
+    nonce: bytesToHex6(nonce),
+    fileId: params.fileId,
+    encryptedDEK: bytesToHex6(encryptedDEK),
+    dekNonce: bytesToHex6(dekNonce),
+    encryptedFileDEK: bytesToHex6(encryptedFileDEK),
+    fileDEKNonce: bytesToHex6(fileDEKNonce)
   };
+  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
+  return decryptPayload(response.encryptedResponse, sharedSecret, hexToBytes6(response.nonce));
 }
-function createAudioClient(apiKey, encryptionKeys, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
-  async function createTranscription(body) {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
-    try {
-      const sessionId = await attest(apiKey, { model: body.model, enabled: attest2 });
-      const encryptedRequest = await preprocessAudioRequest(body, encryptionKeys);
-      const response = await fetch(`${endpoints.proxy}/rvenc/audio/transcriptions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: apiKey,
-          ...sessionId && { "X-Session-Id": sessionId }
-        },
-        body: JSON.stringify(encryptedRequest.body),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        await throwIfErrorResponse(response);
-      }
-      clearTimeout(timeoutId);
-      return await postprocessTranscriptionResponse(response, encryptedRequest.sharedSecret);
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timed out after ${requestTimeoutMs}ms`);
-      }
-      throw error;
-    }
+async function callRagTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
+  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
+  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
+  const { encrypted, nonce } = encryptPayload(sharedSecret, params);
+  const dek = randomBytes4(32);
+  const { encrypted: encryptedDEK, nonce: dekNonce } = encryptPayload(sharedSecret, dek);
+  if (!dekStore.fileDEKs) {
+    dekStore.fileDEKs = new Map;
+  }
+  let fileIds = [];
+  if (dekStore.fileDEKs.size > 0) {
+    fileIds = Array.from(dekStore.fileDEKs.keys());
   }
-  const transcriptionsClient = {
-    create: createTranscription
-  };
-  async function createTranslation(body) {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
-    try {
-      const sessionId = await attest(apiKey, { model: body.model, enabled: attest2 });
-      const encryptedRequest = await preprocessAudioTranslationRequest(body, encryptionKeys);
-      const response = await fetch(`${endpoints.proxy}/rvenc/audio/translations`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: apiKey,
-          ...sessionId && { "X-Session-Id": sessionId }
-        },
-        body: JSON.stringify(encryptedRequest.body),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        await throwIfErrorResponse(response);
-      }
-      clearTimeout(timeoutId);
-      return await postprocessTranslationResponse(response, encryptedRequest.sharedSecret);
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timed out after ${requestTimeoutMs}ms`);
-      }
-      throw error;
+  const _clientKEK = clientKEK ? hexToBytes6(clientKEK) : getClientKEK();
+  const encryptedFileDEKs = fileIds.reduce((acc, fileId) => {
+    const fileDEK = dekStore.fileDEKs?.get(fileId);
+    if (!fileDEK) {
+      return acc;
     }
+    const unwrappedFileDEK = unwrapDEK(_clientKEK, fileDEK);
+    const { encrypted: encryptedFileDEK, nonce: fileDEKNonce } = encryptPayload(sharedSecret, unwrappedFileDEK);
+    acc.push({
+      fileId,
+      encryptedDEK: bytesToHex6(encryptedFileDEK),
+      nonce: bytesToHex6(fileDEKNonce)
+    });
+    return acc;
+  }, []);
+  if (!dekStore.ragDEK) {
+    throw new Error("RAG DEK not found in dekStore. Please upload at least one file with ragIndex: true to initialize RAG.");
   }
-  const translationsClient = {
-    create: createTranslation
+  if (!dekStore.ragVersion) {
+    throw new Error("RAG Version not found in dekStore. Please upload at least one file with ragIndex: true to initialize RAG.");
+  }
+  const ragDEK = unwrapDEK(_clientKEK, dekStore.ragDEK);
+  const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
+  const { encrypted: encryptedRagVersion, nonce: ragVersionNonce } = encryptPayload(sharedSecret, dekStore.ragVersion);
+  const body = {
+    cipherText: bytesToHex6(cipherText),
+    encryptedParams: bytesToHex6(encrypted),
+    nonce: bytesToHex6(nonce),
+    encryptedDEK: bytesToHex6(encryptedDEK),
+    dekNonce: bytesToHex6(dekNonce),
+    encryptedFileDEKs,
+    encryptedRagDEK: bytesToHex6(encryptedRagDEK),
+    ragDEKNonce: bytesToHex6(ragDEKNonce),
+    encryptedRagVersion: bytesToHex6(encryptedRagVersion),
+    ragVersionNonce: bytesToHex6(ragVersionNonce)
   };
+  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
+  return decryptPayload(response.encryptedResponse, sharedSecret, hexToBytes6(response.nonce));
+}
+async function callTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
+  if (FILE_OUTPUT_TOOLS.includes(toolName)) {
+    return callFileOutputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs, attest2);
+  } else if (FILE_INPUT_TOOLS.includes(toolName)) {
+    return callFileInputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs, attest2);
+  } else if (RAG_TOOLS.includes(toolName)) {
+    return callRagTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs, attest2);
+  } else {
+    return callSimpleTool(toolName, params, apiKey, timeoutMs, attest2);
+  }
+}
+function createToolsClient(apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
   return {
-    transcriptions: transcriptionsClient,
-    translations: translationsClient
+    generateImage: (params) => callTool("generateImage", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    audioGenerateFromText: (params) => callTool("audioGenerateFromText", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    createFileForUser: (params) => callTool("createFileForUser", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    imageDescribeAndCaption: (params) => callTool("imageDescribeAndCaption", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    imageDescribeAndCaptionFallback: (params) => callTool("imageDescribeAndCaptionFallback", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    videoDescribeAndCaption: (params) => callTool("videoDescribeAndCaption", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getPDFContent: (params) => callTool("getPDFContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getTextDocumentContent: (params) => callTool("getTextDocumentContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    transcribeAudioToText: (params) => callTool("transcribeAudioToText", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    transcribeAudioWithDiarization: (params) => callTool("transcribeAudioWithDiarization", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    audioDiarization: (params) => callTool("audioDiarization", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getFileContentOCR: (params) => callTool("getFileContentOCR", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getSpreadsheetContent: (params) => callTool("getSpreadsheetContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getDataFileContent: (params) => callTool("getDataFileContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getPowerPointContent: (params) => callTool("getPowerPointContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    getTime: (params) => callTool("getTime", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    webSearchTool: (params) => callTool("webSearchTool", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    webPageScraperTool: (params) => callTool("webPageScraperTool", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
+    searchRag: (params) => callTool("searchRag", params, apiKey, dekStore, clientKEK, timeoutMs, attest2)
   };
 }
 
-// src/files/index.ts
-import { bytesToHex as bytesToHex5, hexToBytes as hexToBytes4, randomBytes as randomBytes4 } from "@noble/ciphers/utils.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { isValid, parseISO } from "date-fns";
-import { z } from "zod";
+// src/core.ts
+async function createRvencClient(options) {
+  const {
+    apiKey,
+    clientKEK,
+    requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+    maxBufferSize = DEFAULT_MAX_BUFFER_SIZE,
+    attest: attest2 = true
+  } = options;
+  if (options.config?.endpoints !== undefined) {
+    Object.assign(endpoints, options.config.endpoints);
+  }
+  let encryptionKeys;
+  try {
+    encryptionKeys = options.encryptionKeys ?? await generateEncryptionKeys(requestTimeoutMs);
+  } catch (error) {
+    throw new Error(`Failed to initialize encryption keys: ${error instanceof Error ? error.message : error}`);
+  }
+  const dekStore = options.dekStore ?? initializeDEKStore(clientKEK);
+  const client = createRvencChatClient(apiKey, encryptionKeys, requestTimeoutMs, maxBufferSize, attest2, options.config?.openAIClientOptions ?? {});
+  client.files = createFilesClient(apiKey, dekStore, clientKEK, requestTimeoutMs);
+  client.tools = createToolsClient(apiKey, dekStore, clientKEK, requestTimeoutMs, attest2);
+  client.audio = createAudioClient(apiKey, encryptionKeys, requestTimeoutMs, attest2);
+  client.models = createModelsClient(apiKey, requestTimeoutMs);
+  client.dekStore = dekStore;
+  return client;
+}
+var core_default = createRvencClient;
 
-// src/utils/dek-store.ts
-import { bytesToHex as bytesToHex4, hexToBytes as hexToBytes3, randomBytes as randomBytes3 } from "@noble/ciphers/utils.js";
-function initializeDEKStore(clientKEK) {
-  const ragDEK = randomBytes3(32);
-  const _clientKEK = clientKEK ? hexToBytes3(clientKEK) : getClientKEK();
-  const wrappedRagDEK = wrapDEK(_clientKEK, ragDEK);
-  return {
-    fileDEKs: new Map,
-    ragDEK: wrappedRagDEK,
-    ragVersion: "2"
-  };
+// src/server/create-app.ts
+import express from "express";
+
+// src/anthropic/http.ts
+import { bytesToHex as bytesToHex7, randomBytes as randomBytes5 } from "@noble/ciphers/utils.js";
+var ANTHROPIC_VERSION_DEFAULT = "2023-06-01";
+var ANTHROPIC_VERSION_DATE = /^\d{4}-\d{2}-\d{2}$/;
+function isAnthropicApiVersionSupported(version) {
+  if (version === ANTHROPIC_VERSION_DEFAULT) {
+    return true;
+  }
+  return ANTHROPIC_VERSION_DATE.test(version);
 }
-function getClientKEK() {
-  if (!process.env.CLIENT_KEK) {
-    throw new Error("CLIENT_KEK environment variable is not set.");
+function newAnthropicRequestId() {
+  return `req_${bytesToHex7(randomBytes5(12))}`;
+}
+function newAnthropicMessageId() {
+  return `msg_${bytesToHex7(randomBytes5(12))}`;
+}
+function extractAnthropicApiKey(req) {
+  const raw = req.headers["x-api-key"];
+  if (typeof raw === "string" && raw.length > 0) {
+    return raw;
   }
-  return hexToBytes3(process.env.CLIENT_KEK);
+  if (Array.isArray(raw) && raw[0]) {
+    return raw[0];
+  }
+  const authHeader = req.headers.authorization;
+  if (!authHeader) {
+    return null;
+  }
+  if (authHeader.startsWith("Bearer ")) {
+    return authHeader.slice(7);
+  }
+  return authHeader;
 }
-function getClientKID(clientKEK) {
-  if (clientKEK) {
-    return bytesToHex4(keyIdFromKEK(hexToBytes3(clientKEK)));
+function getAnthropicVersionHeader(req) {
+  const raw = req.headers["anthropic-version"];
+  if (typeof raw === "string" && raw.length > 0) {
+    return raw;
   }
-  const _clientKEK = getClientKEK();
-  return bytesToHex4(keyIdFromKEK(_clientKEK));
+  if (Array.isArray(raw) && raw[0]) {
+    return raw[0];
+  }
+  return null;
 }
-
-// src/files/index.ts
-var MAX_FILENAME_LENGTH = 255;
-var MIN_FILENAME_LENGTH = 1;
-var ALLOWED_MIME_TYPES = new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-  "application/pdf",
-  "application/msword",
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  "application/vnd.ms-excel",
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  "text/plain",
-  "text/csv",
-  "text/markdown",
-  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  "video/mp4",
-  "video/webm",
-  "video/quicktime",
-  "audio/mpeg",
-  "audio/wav",
-  "audio/ogg",
-  "application/zip",
-  "application/x-rar-compressed",
-  "application/x-7z-compressed",
-  "application/octet-stream"
-]);
-var ApiKeySchema = z.string().trim().min(1, "API key cannot be empty");
-var TimeoutSchema = z.number().int().min(1, "Timeout must be at least 1ms").max(600000, "Timeout must not exceed 600000ms (10 minutes)");
-var DEKStoreSchema = z.object({
-  ragDEK: z.instanceof(Uint8Array).optional(),
-  fileDEKs: z.instanceof(Map).optional()
-});
-var ISO8601DateSchema = z.string().refine((val) => {
-  const date = parseISO(val);
-  return isValid(date);
-}, { message: "Must be a valid ISO8601 date" });
-var MimeTypeSchema = z.string().refine((val) => ALLOWED_MIME_TYPES.has(val), {
-  message: "MIME type is not allowed"
-});
-var FileUploadOptionsSchema = z.object({
-  file: z.instanceof(Uint8Array),
-  fileName: z.string().min(MIN_FILENAME_LENGTH, "File name cannot be empty").max(MAX_FILENAME_LENGTH, `File name cannot exceed ${MAX_FILENAME_LENGTH} characters`).refine((name) => !/[<>:"|?*\x00-\x1F]/.test(name), "Invalid characters").refine((name) => !name.includes("..") && !name.includes("/") && !name.includes("\\"), "No path separators allowed"),
-  mimeType: z.string().optional(),
-  ragIndex: z.boolean().optional()
-});
-var ListFilesOptionsSchema = z.object({
-  limit: z.number().int().positive("Limit must be a positive integer").optional(),
-  offset: z.number().int().nonnegative("Offset must be a non-negative integer").optional(),
-  search: z.string().optional(),
-  from: ISO8601DateSchema.optional(),
-  to: ISO8601DateSchema.optional()
-}).optional();
-var GetFileOptionsSchema = z.object({
-  id: z.string().trim().min(1, "File ID cannot be empty"),
-  url: z.boolean().optional()
-});
-var DeleteFileOptionsSchema = z.object({
-  id: z.string().min(1, "File ID is required")
-});
-var IndexFileInputSchema = z.object({
-  fileId: z.string().min(1, "File ID is required"),
-  filePath: z.string().min(1, "File path is required"),
-  fileDEK: z.instanceof(Uint8Array).optional()
-});
-var IndexFilesOptionsSchema = z.object({
-  files: z.array(IndexFileInputSchema).min(1, "Files array must not be empty"),
-  ragDEK: z.instanceof(Uint8Array).optional()
-});
-var DeleteIndexOptionsSchema = z.object({
-  fileIds: z.array(z.string().min(1)).min(1, "File IDs array must not be empty"),
-  ragDEK: z.instanceof(Uint8Array).optional()
-});
-function validateAPIKey(apiKey) {
-  ApiKeySchema.parse(apiKey);
+function resolveAnthropicVersion(req) {
+  const header = getAnthropicVersionHeader(req);
+  const version = header ?? ANTHROPIC_VERSION_DEFAULT;
+  if (!isAnthropicApiVersionSupported(version)) {
+    return {
+      ok: false,
+      message: `Unsupported anthropic-version: ${version}. Expected a dated version (YYYY-MM-DD) or ${ANTHROPIC_VERSION_DEFAULT}.`
+    };
+  }
+  return { ok: true, version };
 }
-function validateDEKStore(dekStore) {
-  DEKStoreSchema.parse(dekStore);
+function sendAnthropicHttpError(res, status, errorType, message, requestId) {
+  res.setHeader("request-id", requestId);
+  res.status(status).json({
+    type: "error",
+    error: { type: errorType, message },
+    request_id: requestId
+  });
 }
-function validateMimeType(mimeType) {
-  MimeTypeSchema.parse(mimeType);
+function httpStatusToAnthropicErrorType(status) {
+  if (status === 401) {
+    return "authentication_error";
+  }
+  if (status === 402) {
+    return "billing_error";
+  }
+  if (status === 403) {
+    return "permission_error";
+  }
+  if (status === 404) {
+    return "not_found_error";
+  }
+  if (status === 413) {
+    return "request_too_large";
+  }
+  if (status === 429) {
+    return "rate_limit_error";
+  }
+  if (status === 504) {
+    return "timeout_error";
+  }
+  if (status === 529) {
+    return "overloaded_error";
+  }
+  if (status >= 400 && status < 500) {
+    return "invalid_request_error";
+  }
+  return "api_error";
 }
-function validateFileUploadOptions(options) {
-  FileUploadOptionsSchema.parse(options);
+function extractErrorMessage(err) {
+  if (!err || typeof err !== "object") {
+    return null;
+  }
+  const o = err;
+  if (typeof o.message === "string" && o.message.length > 0) {
+    return o.message;
+  }
+  if (typeof o.error === "string" && o.error.length > 0) {
+    return o.error;
+  }
+  if (o.error && typeof o.error === "object") {
+    const nested = o.error.message;
+    if (typeof nested === "string" && nested.length > 0) {
+      return nested;
+    }
+  }
+  return null;
 }
-function validateListFilesOptions(options) {
-  ListFilesOptionsSchema.parse(options);
+function looksLikeApiErrorResponse(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const o = err;
+  if (typeof o.status !== "number")
+    return false;
+  return "error" in o || "message" in o;
 }
-function validateGetFileOptions(options) {
-  GetFileOptionsSchema.parse(options);
+function mapUnknownErrorToAnthropicResponse(err, res, requestId) {
+  if (looksLikeApiErrorResponse(err)) {
+    const status = err.status >= 400 && err.status < 600 ? err.status : 500;
+    const message2 = extractErrorMessage(err) ?? "Request failed";
+    const errorType = httpStatusToAnthropicErrorType(status);
+    sendAnthropicHttpError(res, status, errorType, message2, requestId);
+    return;
+  }
+  const message = extractErrorMessage(err) ?? (err instanceof Error ? err.message : "Internal server error");
+  sendAnthropicHttpError(res, 500, "api_error", message, requestId);
 }
-function guessMimeType(fileName) {
-  const ext = fileName.toLowerCase().split(".").pop() || "";
-  const mimeTypeMap = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    pdf: "application/pdf",
-    doc: "application/msword",
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    xls: "application/vnd.ms-excel",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    txt: "text/plain",
-    csv: "text/csv",
-    md: "text/markdown",
-    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    mov: "video/quicktime",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    ogg: "audio/ogg",
-    zip: "application/zip",
-    rar: "application/x-rar-compressed",
-    "7z": "application/x-7z-compressed"
-  };
-  return mimeTypeMap[ext] || "application/octet-stream";
+function writeAnthropicSseEvent(res, event, data) {
+  res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
 }
-async function saveRagDEKToBackend(apiKey, wrappedRagDEK, timeoutMs) {
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(`${endpoints.proxy}/users/save_rag_dek`, {
-      method: "POST",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        data: {
-          wrappedRagDEK,
-          confirmReplaceRagDEK: true
-        }
-      }),
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to save RAG DEK: HTTP ${response.status}`);
+
+// src/anthropic/to-openai.ts
+class AnthropicRequestValidationError extends Error {
+  status = 400;
+  anthropicType = "invalid_request_error";
+  constructor(message) {
+    super(message);
+    this.name = "AnthropicRequestValidationError";
+  }
+}
+function systemToOpenAiMessages(system) {
+  if (typeof system === "string") {
+    if (system.length === 0) {
+      return [];
     }
-    const result = await response.json();
-    if (result.error) {
-      throw new Error(result.error);
+    return [{ role: "system", content: system }];
+  }
+  if (Array.isArray(system)) {
+    const parts = [];
+    for (const block of system) {
+      if (block && block.type === "text" && typeof block.text === "string") {
+        parts.push(block.text);
+      } else if (block && typeof block === "object") {
+        console.warn(`[proxy] system block type "${block.type}" is not supported and will be ignored.`);
+      }
     }
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Save RAG DEK request timed out after ${timeoutMs}ms`);
+    if (parts.length === 0) {
+      return [];
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
+    return [{ role: "system", content: parts.join(`
+
+`) }];
   }
-}
-async function prepareEncryptedPayload(dekStore, options, apiKey, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  const fileBytes = options.file;
-  const mimeType = options.mimeType || guessMimeType(options.fileName);
-  validateMimeType(mimeType);
-  const dek = randomBytes4(32);
-  const encryptedFile = encryptWithDEK(dek, fileBytes);
-  const encryptedName = encryptMetadataWithDEK(dek, options.fileName);
-  const encryptedMimeType = encryptMetadataWithDEK(dek, mimeType);
-  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
-  const wrappedDEK = wrapDEK(_clientKEK, dek);
-  const clientKID = clientKEK ? getClientKID(clientKEK) : getClientKID();
-  const filePayload = {
-    client_hash: bytesToHex5(sha2562(fileBytes)),
-    encrypted_content: bytesToHex5(encryptedFile),
-    encrypted_name: encryptedName,
-    kid: clientKID,
-    mime_type: encryptedMimeType,
-    version: "2",
-    wrapped_dek: bytesToHex5(wrappedDEK)
-  };
-  if (options.ragIndex) {
-    await addRagIndexToPayload(dekStore, dek, filePayload, apiKey, clientKEK, timeoutMs);
+  if (system.type === "text" && typeof system.text === "string") {
+    return [{ role: "system", content: system.text }];
   }
-  return { dek, filePayload };
+  throw new AnthropicRequestValidationError("Invalid system parameter shape.");
 }
-async function addRagIndexToPayload(dekStore, dek, filePayload, apiKey, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  let ragDEK = dekStore.ragDEK;
-  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
-  if (!ragDEK) {
-    ragDEK = randomBytes4(32);
-    const wrappedRagDEK = wrapDEK(_clientKEK, ragDEK);
-    dekStore.ragDEK = wrappedRagDEK;
-    try {
-      await saveRagDEKToBackend(apiKey, bytesToHex5(wrappedRagDEK), timeoutMs);
-    } catch (error) {
-      console.error("Warning: Failed to save RAG DEK to backend:", error);
+function toolResultContentToString(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content === null || content === undefined) {
+    return "";
+  }
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (block && typeof block === "object" && "type" in block && block.type === "text" && typeof block.text === "string") {
+        parts.push(block.text);
+      } else {
+        parts.push(JSON.stringify(block));
+      }
     }
-  } else {
-    ragDEK = unwrapDEK(_clientKEK, ragDEK);
+    return parts.join(`
+`);
   }
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const { encrypted: encryptedFileDEK, nonce: fileNonce } = encryptPayload(sharedSecret, dek);
-  const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
-  filePayload.encrypted_file_dek = bytesToHex5(encryptedFileDEK);
-  filePayload.encrypted_rag_dek = bytesToHex5(encryptedRagDEK);
-  filePayload.file_nonce = bytesToHex5(fileNonce);
-  filePayload.rag_dek_nonce = bytesToHex5(ragDEKNonce);
-  filePayload.cipher_text = bytesToHex5(cipherText);
+  return JSON.stringify(content);
 }
-async function performUpload(apiKey, filePayload, controller) {
-  const uploadResponse = await fetch(`${endpoints.proxy}/files/encrypted/upload`, {
-    method: "POST",
-    headers: {
-      Authorization: apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(filePayload),
-    signal: controller.signal
-  });
-  if (!uploadResponse.ok) {
-    let errorMessage = `Upload request failed with status ${uploadResponse.status}`;
-    try {
-      const body = await uploadResponse.json();
-      if (body.error) {
-        errorMessage = body.error;
-      }
-    } catch {}
-    throw new Error(errorMessage);
+function anthropicImageBlockToOpenAIPart(part) {
+  const source = part.source;
+  if (!source || typeof source !== "object") {
+    return null;
   }
-  const uploadResult = await uploadResponse.json();
-  if (uploadResult.status !== 200) {
-    throw new Error(uploadResult.error || "Upload failed");
+  const s = source;
+  if (s.type === "base64" && typeof s.data === "string" && s.data.length > 0) {
+    const mediaType = typeof s.media_type === "string" && s.media_type.length > 0 ? s.media_type : "image/png";
+    return {
+      type: "image_url",
+      image_url: { url: `data:${mediaType};base64,${s.data}` }
+    };
   }
-  if (!uploadResult.data) {
-    throw new Error("Upload response missing data");
+  if (s.type === "url" && typeof s.url === "string" && s.url.length > 0) {
+    return { type: "image_url", image_url: { url: s.url } };
   }
-  return uploadResult.data;
+  return null;
 }
-function storeDEKForFile(dekStore, fileId, dek, clientKEK) {
-  if (!dekStore.fileDEKs) {
-    dekStore.fileDEKs = new Map;
+function anthropicUserContentToOpenAIMessages(content) {
+  if (typeof content === "string") {
+    return [{ role: "user", content }];
   }
-  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
-  const wrappedDEK = wrapDEK(_clientKEK, dek);
-  dekStore.fileDEKs.set(fileId, wrappedDEK);
-}
-async function uploadFile(apiKey, dekStore, options, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  validateAPIKey(apiKey);
-  validateDEKStore(dekStore);
-  validateFileUploadOptions(options);
-  TimeoutSchema.parse(timeoutMs);
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const { dek, filePayload } = await prepareEncryptedPayload(dekStore, options, apiKey, clientKEK, timeoutMs);
-    const uploadedFile = await performUpload(apiKey, filePayload, controller);
-    storeDEKForFile(dekStore, uploadedFile.id, dek, clientKEK);
-    return uploadedFile;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`File upload timed out after ${timeoutMs}ms`);
+  const out = [];
+  const partsBuf = [];
+  const flushParts = () => {
+    if (partsBuf.length === 0) {
+      return;
+    }
+    if (partsBuf.length === 1 && partsBuf[0].type === "text") {
+      out.push({ role: "user", content: partsBuf[0].text });
+    } else {
+      out.push({ role: "user", content: [...partsBuf] });
+    }
+    partsBuf.length = 0;
+  };
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      throw new AnthropicRequestValidationError("Invalid message content entry.");
+    }
+    if (part.type === "text" && typeof part.text === "string") {
+      partsBuf.push({
+        type: "text",
+        text: part.text
+      });
+      continue;
+    }
+    if (part.type === "image") {
+      const imgPart = anthropicImageBlockToOpenAIPart(part);
+      if (imgPart) {
+        partsBuf.push(imgPart);
+      }
+      continue;
+    }
+    if (part.type === "tool_result") {
+      flushParts();
+      const id = part.tool_use_id;
+      const rawContent = part.content;
+      if (typeof id !== "string" || id.length === 0) {
+        throw new AnthropicRequestValidationError("tool_result blocks require a non-empty tool_use_id.");
+      }
+      out.push({
+        role: "tool",
+        tool_call_id: id,
+        content: toolResultContentToString(rawContent)
+      });
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
   }
+  flushParts();
+  return out;
 }
-async function listFiles(apiKey, options, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  validateAPIKey(apiKey);
-  validateListFilesOptions(options);
-  TimeoutSchema.parse(timeoutMs);
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  const queryParams = new URLSearchParams;
-  if (options?.limit !== undefined) {
-    queryParams.append("limit", options.limit.toString());
+function anthropicAssistantContentToOpenAI(content) {
+  if (typeof content === "string") {
+    return { role: "assistant", content };
   }
-  if (options?.offset !== undefined) {
-    queryParams.append("offset", options.offset.toString());
+  const textParts = [];
+  const toolCalls = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      throw new AnthropicRequestValidationError("Invalid message content entry.");
+    }
+    if (part.type === "text" && typeof part.text === "string") {
+      textParts.push(part.text);
+      continue;
+    }
+    if (part.type === "tool_use") {
+      const p = part;
+      if (typeof p.id !== "string" || p.id.length === 0) {
+        throw new AnthropicRequestValidationError("tool_use blocks require a non-empty id.");
+      }
+      if (typeof p.name !== "string" || p.name.length === 0) {
+        throw new AnthropicRequestValidationError("tool_use blocks require a non-empty name.");
+      }
+      const args = typeof p.input === "string" ? p.input : JSON.stringify(p.input ?? {});
+      toolCalls.push({
+        id: p.id,
+        type: "function",
+        function: { name: p.name, arguments: args }
+      });
+    }
   }
-  if (options?.search) {
-    queryParams.append("search", options.search);
+  const msg = {
+    role: "assistant",
+    content: textParts.length > 0 ? textParts.join(`
+`) : null
+  };
+  if (toolCalls.length > 0) {
+    msg.tool_calls = toolCalls;
   }
-  if (options?.from) {
-    queryParams.append("from", options.from);
+  return msg;
+}
+function anthropicToolsToOpenAI(tools) {
+  if (tools === undefined) {
+    return;
   }
-  if (options?.to) {
-    queryParams.append("to", options.to);
+  if (!Array.isArray(tools)) {
+    throw new AnthropicRequestValidationError("tools must be an array.");
   }
-  const queryString = queryParams.toString();
-  const url = `${endpoints.proxy}/files/encrypted${queryString ? `?${queryString}` : ""}`;
-  try {
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`List files request failed with status ${response.status}`);
-    }
-    const result = await response.json();
-    if (result.status !== 200) {
-      throw new Error(result.error || "List files failed");
+  const out = [];
+  for (const t of tools) {
+    if (!t || typeof t !== "object") {
+      throw new AnthropicRequestValidationError("Invalid tool entry.");
     }
-    if (!result.data) {
-      throw new Error("List files response missing data");
+    const name = t.name;
+    const desc = t.description;
+    const schema = t.input_schema;
+    if (typeof name !== "string" || name.length === 0) {
+      throw new AnthropicRequestValidationError("Each tool must include a non-empty name.");
     }
-    return result.data;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`List files request timed out after ${timeoutMs}ms`);
+    if (schema !== undefined && (typeof schema !== "object" || schema === null)) {
+      throw new AnthropicRequestValidationError("tool input_schema must be an object when provided.");
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
+    out.push({
+      type: "function",
+      function: {
+        name,
+        ...typeof desc === "string" ? { description: desc } : {},
+        parameters: schema ?? {
+          type: "object",
+          properties: {}
+        }
+      }
+    });
   }
+  return out;
 }
-async function getFile(apiKey, options, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  validateAPIKey(apiKey);
-  validateGetFileOptions(options);
-  TimeoutSchema.parse(timeoutMs);
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  const queryParams = new URLSearchParams;
-  if (options.url !== undefined) {
-    queryParams.append("url", options.url ? "true" : "false");
+function anthropicToolChoiceToOpenAI(toolChoice) {
+  if (toolChoice === undefined) {
+    return;
   }
-  const queryString = queryParams.toString();
-  const url = `${endpoints.proxy}/files/encrypted/${options.id}${queryString ? `?${queryString}` : ""}`;
-  try {
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      if (response.status === 404) {
-        throw new Error(`File not found: ${options.id}`);
+  if (typeof toolChoice !== "object" || toolChoice === null || !("type" in toolChoice)) {
+    throw new AnthropicRequestValidationError("Invalid tool_choice shape.");
+  }
+  const tc = toolChoice;
+  switch (tc.type) {
+    case "auto":
+      return "auto";
+    case "none":
+      return "none";
+    case "any":
+      return "required";
+    case "tool": {
+      if (typeof tc.name !== "string" || tc.name.length === 0) {
+        throw new AnthropicRequestValidationError('tool_choice type "tool" requires a non-empty name.');
       }
-      throw new Error(`Get file request failed with status ${response.status}`);
+      return { type: "function", function: { name: tc.name } };
+    }
+    default:
+      throw new AnthropicRequestValidationError(`Unsupported tool_choice type "${tc.type}".`);
+  }
+}
+function anthropicMessagesCreateToOpenAI(body) {
+  if (typeof body.model !== "string" || !body.model) {
+    throw new AnthropicRequestValidationError("model is required.");
+  }
+  if (typeof body.max_tokens !== "number" || !Number.isFinite(body.max_tokens)) {
+    throw new AnthropicRequestValidationError("max_tokens is required and must be a number.");
+  }
+  if (!Array.isArray(body.messages)) {
+    throw new AnthropicRequestValidationError("messages must be an array.");
+  }
+  const messages = [];
+  if (body.system !== undefined) {
+    messages.push(...systemToOpenAiMessages(body.system));
+  }
+  for (const m of body.messages) {
+    if (m.role === "system") {
+      messages.push(...systemToOpenAiMessages(m.content));
+      continue;
     }
-    const result = await response.json();
-    if (result.status !== 200) {
-      throw new Error(result.error || "Get file failed");
+    if (m.role !== "user" && m.role !== "assistant") {
+      throw new AnthropicRequestValidationError(`Invalid message role "${m.role}".`);
     }
-    if (!result.data) {
-      throw new Error("Get file response missing data");
+    if (m.role === "user") {
+      messages.push(...anthropicUserContentToOpenAIMessages(m.content));
+    } else {
+      messages.push(anthropicAssistantContentToOpenAI(m.content));
     }
-    return result.data;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Get file request timed out after ${timeoutMs}ms`);
+  }
+  const isStreaming = Boolean(body.stream);
+  const params = {
+    model: body.model,
+    messages,
+    max_tokens: body.max_tokens,
+    stream: isStreaming
+  };
+  if (isStreaming) {
+    params.stream_options = { include_usage: true };
+  }
+  const tools = anthropicToolsToOpenAI(body.tools);
+  if (tools !== undefined && tools.length > 0) {
+    params.tools = tools;
+  }
+  const toolChoice = anthropicToolChoiceToOpenAI(body.tool_choice);
+  if (toolChoice !== undefined) {
+    params.tool_choice = toolChoice;
+  }
+  if (body.stop_sequences !== undefined) {
+    if (!Array.isArray(body.stop_sequences) || !body.stop_sequences.every((s) => typeof s === "string")) {
+      throw new AnthropicRequestValidationError("stop_sequences must be an array of strings.");
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
+    params.stop = body.stop_sequences;
   }
+  if (typeof body.temperature === "number") {
+    params.temperature = body.temperature;
+  }
+  if (typeof body.top_p === "number") {
+    params.top_p = body.top_p;
+  }
+  if (typeof body.top_k === "number") {
+    console.warn("[proxy] top_k is not supported by the OpenAI API and will be ignored.");
+  }
+  return params;
 }
-async function deleteFile(apiKey, options, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  validateAPIKey(apiKey);
-  DeleteFileOptionsSchema.parse(options);
-  TimeoutSchema.parse(timeoutMs);
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(`${endpoints.proxy}/files/encrypted/${options.id}`, {
-      method: "DELETE",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      if (response.status === 404) {
-        throw new Error(`File not found: ${options.id}`);
+
+// src/anthropic/count-tokens-route.ts
+function extractTextCharCount(body) {
+  let len = 0;
+  if (typeof body.system === "string") {
+    len += body.system.length;
+  } else if (Array.isArray(body.system)) {
+    for (const block of body.system) {
+      if (block && block.type === "text" && typeof block.text === "string") {
+        len += block.text.length;
       }
-      throw new Error(`Delete file request failed with status ${response.status}`);
     }
-    await response.json();
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Delete file request timed out after ${timeoutMs}ms`);
+  } else if (body.system && typeof body.system === "object" && body.system.type === "text") {
+    len += body.system.text.length;
+  }
+  for (const msg of body.messages) {
+    if (typeof msg.content === "string") {
+      len += msg.content.length;
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (!part || typeof part !== "object")
+          continue;
+        if (part.type === "text" && typeof part.text === "string") {
+          len += part.text.length;
+        } else if (part.type === "tool_result") {
+          const c = part.content;
+          if (typeof c === "string") {
+            len += c.length;
+          }
+        }
+      }
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
   }
-}
-async function indexFiles(apiKey, dekStore, options, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  validateAPIKey(apiKey);
-  validateDEKStore(dekStore);
-  IndexFilesOptionsSchema.parse(options);
-  TimeoutSchema.parse(timeoutMs);
-  const wrappedRagDEK = options.ragDEK || dekStore.ragDEK;
-  if (!wrappedRagDEK) {
-    throw new Error("RAG DEK not found. Provide ragDEK in options or upload at least one file with ragIndex: true.");
+  if (Array.isArray(body.tools)) {
+    len += JSON.stringify(body.tools).length;
   }
-  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
-  const ragDEK = unwrapDEK(_clientKEK, wrappedRagDEK);
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const encryptedFiles = options.files.map((file) => {
-    const wrappedFileDEK = file.fileDEK || dekStore.fileDEKs?.get(file.fileId);
-    if (!wrappedFileDEK) {
-      throw new Error(`File DEK not found for file: ${file.fileId}. Provide fileDEK or ensure file was uploaded with this DEK store.`);
+  return len;
+}
+function registerAnthropicCountTokensRoute(router, _deps) {
+  router.post("/v1/messages/count_tokens", async (req, res) => {
+    const requestId = newAnthropicRequestId();
+    res.setHeader("request-id", requestId);
+    const versionResult = resolveAnthropicVersion(req);
+    if (!versionResult.ok) {
+      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
     }
-    const fileDEK = unwrapDEK(_clientKEK, wrappedFileDEK);
-    const { encrypted: encryptedFileDEK, nonce: fileNonce } = encryptPayload(sharedSecret, fileDEK);
-    const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
-    return {
-      file_id: file.fileId,
-      encrypted_file_dek: bytesToHex5(encryptedFileDEK),
-      encrypted_rag_dek: bytesToHex5(encryptedRagDEK),
-      file_nonce: bytesToHex5(fileNonce),
-      rag_dek_nonce: bytesToHex5(ragDEKNonce),
-      s3_r2_path: file.filePath,
-      cipher_text: bytesToHex5(cipherText)
-    };
-  });
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(`${endpoints.proxy}/files/encrypted/index`, {
-      method: "POST",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ files: encryptedFiles }),
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`Index files request failed with status ${response.status}`);
+    const apiKey = extractAnthropicApiKey(req);
+    if (!apiKey) {
+      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
     }
-    const result = await response.json();
-    return result;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Index files request timed out after ${timeoutMs}ms`);
+    try {
+      const raw = req.body;
+      const body = {
+        ...raw,
+        max_tokens: typeof raw.max_tokens === "number" && Number.isFinite(raw.max_tokens) ? raw.max_tokens : 4096,
+        stream: false
+      };
+      anthropicMessagesCreateToOpenAI(body);
+      const input_tokens = Math.max(1, Math.ceil(extractTextCharCount(body) / 4));
+      res.json({ input_tokens });
+    } catch (err) {
+      if (err instanceof AnthropicRequestValidationError) {
+        return sendAnthropicHttpError(res, err.status, err.anthropicType, err.message, requestId);
+      }
+      mapUnknownErrorToAnthropicResponse(err, res, requestId);
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
-  }
+  });
 }
-async function deleteIndex(apiKey, dekStore, options, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  validateAPIKey(apiKey);
-  validateDEKStore(dekStore);
-  DeleteIndexOptionsSchema.parse(options);
-  TimeoutSchema.parse(timeoutMs);
-  const wrappedRagDEK = options.ragDEK || dekStore.ragDEK;
-  if (!wrappedRagDEK) {
-    throw new Error("RAG DEK not found. Provide ragDEK in options or ensure dekStore has a ragDEK.");
+
+// src/anthropic/from-openai.ts
+function openAiFinishReasonToAnthropic(finish) {
+  if (!finish) {
+    return { stop_reason: null, stop_sequence: null };
   }
-  const _clientKEK = clientKEK ? hexToBytes4(clientKEK) : getClientKEK();
-  const ragDEK = unwrapDEK(_clientKEK, wrappedRagDEK);
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(`${endpoints.proxy}/files/encrypted/delete-index`, {
-      method: "POST",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        cipher_text: bytesToHex5(cipherText),
-        encrypted_rag_dek: bytesToHex5(encryptedRagDEK),
-        rag_dek_nonce: bytesToHex5(ragDEKNonce),
-        fileIds: options.fileIds
-      }),
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`Delete index request failed with status ${response.status}`);
-    }
-    const result = await response.json();
-    return result;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Delete index request timed out after ${timeoutMs}ms`);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
+  switch (finish) {
+    case "stop":
+      return { stop_reason: "end_turn", stop_sequence: null };
+    case "length":
+      return { stop_reason: "max_tokens", stop_sequence: null };
+    case "tool_calls":
+      return { stop_reason: "tool_use", stop_sequence: null };
+    case "content_filter":
+      return { stop_reason: "refusal", stop_sequence: null };
+    default:
+      return { stop_reason: "end_turn", stop_sequence: null };
   }
 }
-function createFilesClient(apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  return {
-    upload: (options) => uploadFile(apiKey, dekStore, options, clientKEK, timeoutMs),
-    list: (options) => listFiles(apiKey, options, timeoutMs),
-    get: (options) => getFile(apiKey, options, timeoutMs),
-    delete: (options) => deleteFile(apiKey, options, timeoutMs),
-    index: (options) => indexFiles(apiKey, dekStore, options, clientKEK, timeoutMs),
-    deleteIndex: (options) => deleteIndex(apiKey, dekStore, options, clientKEK, timeoutMs)
-  };
-}
-
-// src/models/index.ts
-async function listModels(params, apiKey, timeoutMs) {
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  const queryParams = new URLSearchParams;
-  if (params?.type !== undefined) {
-    queryParams.append("type", params.type);
+function extractTextFromAssistantContent(content) {
+  if (content == null) {
+    return "";
   }
-  const queryString = queryParams.toString();
-  const url = `${endpoints.proxy}/models${queryString ? `?${queryString}` : ""}`;
-  try {
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        Authorization: apiKey,
-        "Content-Type": "application/json"
-      },
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`List models request failed with status ${response.status}`);
-    }
-    const result = await response.json();
-    if (result.status !== 200) {
-      throw new Error(result.error || "List models failed");
-    }
-    if (!result.data) {
-      throw new Error("List models response missing data");
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const parts = [];
+  for (const p of content) {
+    if (typeof p === "string") {
+      parts.push(p);
+      continue;
     }
-    return result.data;
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`List models request timed out after ${timeoutMs}ms`);
+    if (p && typeof p === "object" && "type" in p && p.type === "text" && "text" in p) {
+      parts.push(String(p.text));
     }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
   }
+  return parts.join("");
 }
-function createModelsClient(apiKey, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  return {
-    list: (params) => listModels(params, apiKey, timeoutMs)
+function openAIChatCompletionToAnthropicMessage(completion, requestModel) {
+  const choice = completion.choices[0];
+  const message = choice?.message;
+  const contentText = message ? extractTextFromAssistantContent(message.content) : "";
+  const content = [];
+  if (contentText.length > 0) {
+    content.push({ type: "text", text: contentText });
+  }
+  if (message?.tool_calls?.length) {
+    for (const tc of message.tool_calls) {
+      if (tc.type !== "function") {
+        continue;
+      }
+      let input = {};
+      try {
+        input = JSON.parse(tc.function.arguments || "{}");
+      } catch {
+        input = { _raw_arguments: tc.function.arguments ?? "" };
+      }
+      content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        input
+      });
+    }
+  }
+  if (content.length === 0) {
+    content.push({ type: "text", text: "" });
+  }
+  const { stop_reason, stop_sequence } = openAiFinishReasonToAnthropic(choice?.finish_reason);
+  const u = completion.usage;
+  const usage = {
+    input_tokens: u?.prompt_tokens ?? 0,
+    output_tokens: u?.completion_tokens ?? 0
   };
-}
-
-// src/rvenc/index.ts
-import { bytesToHex as bytesToHex6, hexToBytes as hexToBytes5 } from "@noble/ciphers/utils.js";
-import OpenAI from "openai";
-function preprocessRequest(body, encryptionKeys) {
-  const { cipherText, sharedSecret } = encryptionKeys;
-  const { encrypted, nonce } = encryptPayload(sharedSecret, body);
   return {
-    body: {
-      cipherText: bytesToHex6(cipherText),
-      encryptedInference: bytesToHex6(encrypted),
-      nonce: bytesToHex6(nonce),
-      model: body.model,
-      stream: body.stream === true
-    },
-    sharedSecret,
-    nonce
+    id: newAnthropicMessageId(),
+    type: "message",
+    role: "assistant",
+    content,
+    model: requestModel,
+    stop_reason,
+    stop_sequence,
+    usage
   };
 }
-async function postprocessStreamingResponse(response, sharedSecret, nonce, maxBufferSize) {
-  if (!response.body) {
-    throw new Error("Response body is null");
+function chunkFinishToAnthropic(finish) {
+  if (!finish) {
+    return null;
   }
-  const reader = response.body.getReader();
-  const generator = createDecryptedStreamGenerator(reader, sharedSecret, nonce, maxBufferSize);
-  return {
-    [Symbol.asyncIterator]() {
-      return generator;
+  return openAiFinishReasonToAnthropic(finish).stop_reason;
+}
+async function pipeOpenAIChunkStreamToAnthropicSse(res, stream, options) {
+  const { anthropicModel, messageId } = options;
+  let textBlockOpen = false;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let stopReason = null;
+  const toolStates = new Map;
+  let nextAnthropicIndex = 0;
+  let textBlockIndex = null;
+  writeAnthropicSseEvent(res, "message_start", {
+    type: "message_start",
+    message: {
+      id: messageId,
+      type: "message",
+      role: "assistant",
+      content: [],
+      model: anthropicModel,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: inputTokens, output_tokens: outputTokens }
     }
+  });
+  const ensureTextBlock = () => {
+    if (textBlockOpen) {
+      return;
+    }
+    textBlockIndex = nextAnthropicIndex++;
+    textBlockOpen = true;
+    writeAnthropicSseEvent(res, "content_block_start", {
+      type: "content_block_start",
+      index: textBlockIndex,
+      content_block: { type: "text", text: "" }
+    });
   };
-}
-async function postprocessNonStreamingResponse(response, sharedSecret) {
-  const data = await response.json();
-  if (!data.encryptedResponse || !data.nonce) {
-    throw new Error("Invalid non-streaming response: missing encryptedResponse or nonce");
-  }
-  const responseNonce = hexToBytes5(data.nonce);
-  return decryptPayload(data.encryptedResponse, sharedSecret, responseNonce);
-}
-function createRvencChatClient(apiKey, encryptionKeys, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, maxBufferSize = DEFAULT_MAX_BUFFER_SIZE, attest2 = true, OpenAIClientParams) {
-  const client = new OpenAI({ apiKey: "not-used", ...OpenAIClientParams });
-  const originalChatCreate = client.chat.completions.create.bind(client.chat.completions);
-  client.chat.completions.create = async (body) => {
-    const isStreaming = body.stream === true;
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
-    try {
-      const sessionId = await attest(apiKey, { model: body.model, enabled: attest2 });
-      const encryptedRequest = preprocessRequest(body, encryptionKeys);
-      const response = await fetch(`${endpoints.proxy}/rvenc/chat/completions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: isStreaming ? "text/event-stream" : "application/json",
-          Authorization: apiKey,
-          ...sessionId && { "X-Session-Id": sessionId }
-        },
-        body: JSON.stringify(encryptedRequest.body),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        await throwIfErrorResponse(response);
-      }
-      clearTimeout(timeoutId);
-      if (isStreaming) {
-        const contentType = response.headers.get("content-type") ?? "";
-        if (contentType.includes("text/event-stream")) {
-          return await postprocessStreamingResponse(response, encryptedRequest.sharedSecret, encryptedRequest.nonce, maxBufferSize);
-        }
-        const completion = await postprocessNonStreamingResponse(response, encryptedRequest.sharedSecret);
-        return completionToChunkStream(completion);
-      }
-      return await postprocessNonStreamingResponse(response, encryptedRequest.sharedSecret);
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timed out after ${requestTimeoutMs}ms`);
-      }
-      throw error;
+  const closeTextBlockIfOpen = () => {
+    if (!textBlockOpen || textBlockIndex === null) {
+      return;
     }
+    writeAnthropicSseEvent(res, "content_block_stop", {
+      type: "content_block_stop",
+      index: textBlockIndex
+    });
+    textBlockOpen = false;
   };
-  return client;
-}
-async function* completionToChunkStream(completion) {
-  const choice = completion.choices[0];
-  const message = choice?.message;
-  const content = typeof message?.content === "string" ? message.content : "";
-  const toolCalls = message?.tool_calls?.filter((tc) => tc.type === "function").map((tc, i) => ({
-    index: i,
-    id: tc.id,
-    type: "function",
-    function: {
-      name: tc.function.name,
-      arguments: tc.function.arguments
+  const getOrCreateTool = (openAiIdx) => {
+    let st = toolStates.get(openAiIdx);
+    if (!st) {
+      st = {
+        anthropicIndex: nextAnthropicIndex++,
+        id: "",
+        name: "",
+        lastArgs: "",
+        argsEmittedLen: 0,
+        started: false,
+        stopped: false
+      };
+      toolStates.set(openAiIdx, st);
     }
-  }));
-  yield {
-    id: completion.id,
-    object: "chat.completion.chunk",
-    created: completion.created,
-    model: completion.model,
-    choices: [
-      {
-        index: choice?.index ?? 0,
-        delta: {
-          role: "assistant",
-          content,
-          ...toolCalls && toolCalls.length > 0 && { tool_calls: toolCalls }
-        },
-        finish_reason: choice?.finish_reason ?? "stop",
-        logprobs: null
+    return st;
+  };
+  const flushToolArgs = (st) => {
+    if (!st.started || st.lastArgs.length <= st.argsEmittedLen) {
+      return;
+    }
+    const partial = st.lastArgs.slice(st.argsEmittedLen);
+    st.argsEmittedLen = st.lastArgs.length;
+    writeAnthropicSseEvent(res, "content_block_delta", {
+      type: "content_block_delta",
+      index: st.anthropicIndex,
+      delta: {
+        type: "input_json_delta",
+        partial_json: partial
       }
-    ],
-    usage: completion.usage ?? null
+    });
   };
-}
-async function* createDecryptedStreamGenerator(reader, sharedSecret, nonce, maxBufferSize) {
-  const decoder = new TextDecoder;
-  let buffer = "";
   try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      if (buffer.length > maxBufferSize) {
-        throw new Error(`Stream buffer exceeded maximum size of ${maxBufferSize} bytes`);
+    for await (const chunk of stream) {
+      if (chunk.usage) {
+        const u = chunk.usage;
+        inputTokens = u.prompt_tokens ?? inputTokens;
+        outputTokens = u.completion_tokens ?? outputTokens;
       }
-      const parts = buffer.split(`
-
-`);
-      for (let i = 0;i < parts.length - 1; i++) {
-        const part = parts[i];
-        const lines = part.split(`
-`);
-        let event;
-        let data;
-        if (lines[0]) {
-          const eventSplit = lines[0].split(": ");
-          event = eventSplit[1];
-        }
-        if (lines[1]) {
-          const dataSplit = lines[1].split(": ");
-          data = dataSplit.slice(1).join(": ");
-        }
-        if (event === "done" && data === "[DONE]") {
-          return;
-        }
-        if (event === "error") {
-          const errorObj = JSON.parse(data || "{}");
-          throw new Error(errorObj.error?.message || data || "Stream error");
+      const choice = chunk.choices?.[0];
+      if (!choice) {
+        continue;
+      }
+      const delta = choice.delta;
+      if (typeof delta?.content === "string" && delta.content.length > 0) {
+        ensureTextBlock();
+        if (textBlockIndex !== null) {
+          writeAnthropicSseEvent(res, "content_block_delta", {
+            type: "content_block_delta",
+            index: textBlockIndex,
+            delta: { type: "text_delta", text: delta.content }
+          });
         }
-        if (event === "data" && data && data !== "[DONE]") {
-          const chunk = decryptPayload(data, sharedSecret, nonce);
-          if (chunk.error) {
-            throw new Error(chunk.error.message || "Stream error");
+      }
+      if (delta?.tool_calls?.length) {
+        closeTextBlockIfOpen();
+        for (const tc of delta.tool_calls) {
+          const idx = typeof tc.index === "number" && Number.isFinite(tc.index) ? tc.index : 0;
+          const st = getOrCreateTool(idx);
+          if (typeof tc.id === "string" && tc.id.length > 0) {
+            st.id = tc.id;
+          }
+          const fn = tc.function;
+          if (fn?.name && fn.name.length > 0) {
+            st.name = fn.name;
+          }
+          if (typeof fn?.arguments === "string") {
+            st.lastArgs += fn.arguments;
+          }
+          if (!st.started && st.id.length > 0 && st.name.length > 0) {
+            writeAnthropicSseEvent(res, "content_block_start", {
+              type: "content_block_start",
+              index: st.anthropicIndex,
+              content_block: {
+                type: "tool_use",
+                id: st.id,
+                name: st.name
+              }
+            });
+            st.started = true;
+          }
+          if (st.started) {
+            flushToolArgs(st);
           }
-          yield chunk;
         }
       }
-      buffer = parts[parts.length - 1];
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-// src/tools/index.ts
-import { bytesToHex as bytesToHex7, hexToBytes as hexToBytes6, randomBytes as randomBytes5 } from "@noble/ciphers/utils.js";
-var FILE_OUTPUT_TOOLS = ["generateImage", "audioGenerateFromText", "createFileForUser"];
-var FILE_INPUT_TOOLS = [
-  "imageDescribeAndCaption",
-  "imageDescribeAndCaptionFallback",
-  "videoDescribeAndCaption",
-  "getPDFContent",
-  "getTextDocumentContent",
-  "transcribeAudioToText",
-  "transcribeAudioWithDiarization",
-  "audioDiarization",
-  "getSpreadsheetContent",
-  "getPowerPointContent",
-  "getDataFileContent",
-  "getFileContentOCR"
-];
-var RAG_TOOLS = ["searchRag"];
-async function callToolRequest(toolName, body, apiKey, timeoutMs, attest2) {
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(`${endpoints.proxy}/tools/${toolName}`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: apiKey
-      },
-      body: JSON.stringify(body),
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) {
-      await throwIfErrorResponse(response);
+      if (choice.finish_reason) {
+        const mapped = chunkFinishToAnthropic(choice.finish_reason);
+        if (mapped) {
+          stopReason = mapped;
+        }
+      }
     }
-    const data = await response.json();
-    return data.data;
-  } catch (error) {
-    clearTimeout(timeoutId);
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Tool request timed out after ${timeoutMs}ms`);
+    closeTextBlockIfOpen();
+    const sortedTools = [...toolStates.values()].sort((a, b) => a.anthropicIndex - b.anthropicIndex);
+    for (const st of sortedTools) {
+      if (st.started && !st.stopped) {
+        writeAnthropicSseEvent(res, "content_block_stop", {
+          type: "content_block_stop",
+          index: st.anthropicIndex
+        });
+        st.stopped = true;
+      }
     }
-    throw new Error(`Tool request failed: ${error instanceof Error ? error.message : error}`);
+    writeAnthropicSseEvent(res, "message_delta", {
+      type: "message_delta",
+      delta: { stop_reason: stopReason, stop_sequence: null },
+      usage: {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens
+      }
+    });
+    writeAnthropicSseEvent(res, "message_stop", { type: "message_stop" });
+    res.end();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Stream error";
+    writeAnthropicSseEvent(res, "error", {
+      type: "error",
+      error: { type: "api_error", message }
+    });
+    res.end();
   }
 }
-async function downloadEncryptedFile(fileId, apiKey, timeoutMs) {
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const metadataResponse = await fetch(`${endpoints.proxy}/files/encrypted/${fileId}?url=true`, {
-      headers: { Authorization: apiKey },
-      signal: controller.signal
-    });
-    if (!metadataResponse.ok) {
-      throw new Error(`Failed to get file metadata: ${metadataResponse.status}`);
-    }
-    const metadata = await metadataResponse.json();
-    const downloadUrl = metadata.data?.url;
-    if (!downloadUrl) {
-      throw new Error("No download URL in response");
-    }
-    const fileResponse = await fetch(downloadUrl, { signal: controller.signal });
-    if (!fileResponse.ok) {
-      throw new Error(`Failed to download file: ${fileResponse.status}`);
+
+// src/anthropic/messages-route.ts
+function registerAnthropicMessagesRoute(router, deps) {
+  router.post("/v1/messages", async (req, res) => {
+    const requestId = newAnthropicRequestId();
+    res.setHeader("request-id", requestId);
+    const versionResult = resolveAnthropicVersion(req);
+    if (!versionResult.ok) {
+      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
     }
-    clearTimeout(timeoutId);
-    const arrayBuffer = await fileResponse.arrayBuffer();
-    return new Uint8Array(arrayBuffer);
-  } catch (error) {
-    clearTimeout(timeoutId);
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`File download timed out after ${timeoutMs}ms`);
+    const apiKey = extractAnthropicApiKey(req);
+    if (!apiKey) {
+      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
     }
-    throw error;
-  }
-}
-async function downloadAndDecryptFile(response, dek, apiKey, timeoutMs) {
-  if (!response.success || !response.fileId) {
-    return null;
-  }
-  const decryptFileName = (encryptedHex) => {
-    const encrypted = hexToBytes6(encryptedHex);
-    const decrypted = decryptWithDEK(dek, encrypted);
-    return new TextDecoder().decode(decrypted);
-  };
-  const fileName = decryptFileName(response.fileName);
-  const mimeType = decryptFileName(response.mimeType);
-  const encryptedFile = await downloadEncryptedFile(response.fileId, apiKey, timeoutMs);
-  const decryptedFile = decryptWithDEK(dek, encryptedFile);
-  return {
-    fileId: response.fileId,
-    fileName,
-    mimeType,
-    content: decryptedFile,
-    fileSize: decryptedFile.length
-  };
+    try {
+      const body = req.body;
+      const openaiParams = anthropicMessagesCreateToOpenAI(body);
+      const client = await deps.getOrCreateClient(apiKey);
+      const completion = await client.chat.completions.create(openaiParams);
+      if (body.stream) {
+        res.status(200);
+        res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        if (completion && typeof completion === "object" && Symbol.asyncIterator in completion) {
+          const messageId = newAnthropicMessageId();
+          await pipeOpenAIChunkStreamToAnthropicSse(res, completion, {
+            anthropicModel: body.model,
+            messageId
+          });
+        } else {
+          sendAnthropicHttpError(res, 500, "api_error", "Expected streamed completion", requestId);
+        }
+        return;
+      }
+      const message = openAIChatCompletionToAnthropicMessage(completion, body.model);
+      res.json(message);
+    } catch (err) {
+      if (err instanceof AnthropicRequestValidationError) {
+        return sendAnthropicHttpError(res, err.status, err.anthropicType, err.message, requestId);
+      }
+      mapUnknownErrorToAnthropicResponse(err, res, requestId);
+    }
+  });
 }
-async function callSimpleTool(toolName, params, apiKey, timeoutMs, attest2) {
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const { encrypted, nonce } = encryptPayload(sharedSecret, params);
-  const body = {
-    cipherText: bytesToHex7(cipherText),
-    encryptedParams: bytesToHex7(encrypted),
-    nonce: bytesToHex7(nonce)
+
+// src/anthropic/models-route.ts
+function toAnthropicModel(model) {
+  return {
+    type: "model",
+    id: model.model,
+    display_name: model.name || model.model,
+    created_at: model.created_at
   };
-  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
-  return decryptPayload(response.encryptedResponse, sharedSecret, hexToBytes6(response.nonce));
 }
-async function callFileOutputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const { encrypted, nonce } = encryptPayload(sharedSecret, params);
-  const dek = randomBytes5(32);
-  const { encrypted: encryptedDEK, nonce: dekNonce } = encryptPayload(sharedSecret, dek);
-  const _clientKEK = clientKEK ? hexToBytes6(clientKEK) : getClientKEK();
-  const wrappedDEK = wrapDEK(_clientKEK, dek);
-  const clientKID = clientKEK ? getClientKID(clientKEK) : getClientKID();
-  const body = {
-    cipherText: bytesToHex7(cipherText),
-    encryptedParams: bytesToHex7(encrypted),
-    nonce: bytesToHex7(nonce),
-    encryptedDEK: bytesToHex7(encryptedDEK),
-    dekNonce: bytesToHex7(dekNonce),
-    kid: clientKID,
-    wrappedDEK: bytesToHex7(wrappedDEK)
-  };
-  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
-  const result = await downloadAndDecryptFile(response, dek, apiKey, timeoutMs);
-  if (result?.fileId) {
-    if (!dekStore.fileDEKs) {
-      dekStore.fileDEKs = new Map;
-    }
-    dekStore.fileDEKs.set(result.fileId, wrappedDEK);
-  }
-  return result;
+function filterEnabled(models) {
+  return models.filter((m) => m.enabled !== 0);
 }
-async function callFileInputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
-  if (!params.fileId) {
-    throw new Error(`Tool ${toolName} requires fileId parameter`);
-  }
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const dek = randomBytes5(32);
-  const { encrypted: encryptedDEK, nonce: dekNonce } = encryptPayload(sharedSecret, dek);
-  const nonce = randomBytes5(24);
-  if (!dekStore.fileDEKs) {
-    dekStore.fileDEKs = new Map;
+function parseLimit(raw) {
+  if (typeof raw !== "string" || raw.length === 0) {
+    return 20;
   }
-  const _clientKEK = clientKEK ? hexToBytes6(clientKEK) : getClientKEK();
-  let fileDEK = dekStore.fileDEKs.get(params.fileId);
-  if (!fileDEK) {
-    fileDEK = randomBytes5(32);
-    const wrappedFileDEK = wrapDEK(_clientKEK, fileDEK);
-    dekStore.fileDEKs.set(params.fileId, wrappedFileDEK);
-  } else {
-    fileDEK = unwrapDEK(_clientKEK, fileDEK);
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    return 20;
   }
-  const { encrypted: encryptedFileDEK, nonce: fileDEKNonce } = encryptPayload(sharedSecret, fileDEK);
-  const body = {
-    cipherText: bytesToHex7(cipherText),
-    nonce: bytesToHex7(nonce),
-    fileId: params.fileId,
-    encryptedDEK: bytesToHex7(encryptedDEK),
-    dekNonce: bytesToHex7(dekNonce),
-    encryptedFileDEK: bytesToHex7(encryptedFileDEK),
-    fileDEKNonce: bytesToHex7(fileDEKNonce)
-  };
-  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
-  return decryptPayload(response.encryptedResponse, sharedSecret, hexToBytes6(response.nonce));
+  return Math.min(n, 1000);
 }
-async function callRagTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
-  const enclavePublicKey = await getEnclavePublicKey(timeoutMs);
-  const { cipherText, sharedSecret } = createMLKEMEncapsulation(enclavePublicKey);
-  const { encrypted, nonce } = encryptPayload(sharedSecret, params);
-  const dek = randomBytes5(32);
-  const { encrypted: encryptedDEK, nonce: dekNonce } = encryptPayload(sharedSecret, dek);
-  if (!dekStore.fileDEKs) {
-    dekStore.fileDEKs = new Map;
-  }
-  let fileIds = [];
-  if (dekStore.fileDEKs.size > 0) {
-    fileIds = Array.from(dekStore.fileDEKs.keys());
-  }
-  const _clientKEK = clientKEK ? hexToBytes6(clientKEK) : getClientKEK();
-  const encryptedFileDEKs = fileIds.reduce((acc, fileId) => {
-    const fileDEK = dekStore.fileDEKs?.get(fileId);
-    if (!fileDEK) {
-      return acc;
+function paginate(all, beforeId, afterId, limit) {
+  let start = 0;
+  let end = all.length;
+  if (afterId) {
+    const idx = all.findIndex((m) => m.id === afterId);
+    if (idx >= 0) {
+      start = idx + 1;
     }
-    const unwrappedFileDEK = unwrapDEK(_clientKEK, fileDEK);
-    const { encrypted: encryptedFileDEK, nonce: fileDEKNonce } = encryptPayload(sharedSecret, unwrappedFileDEK);
-    acc.push({
-      fileId,
-      encryptedDEK: bytesToHex7(encryptedFileDEK),
-      nonce: bytesToHex7(fileDEKNonce)
-    });
-    return acc;
-  }, []);
-  if (!dekStore.ragDEK) {
-    throw new Error("RAG DEK not found in dekStore. Please upload at least one file with ragIndex: true to initialize RAG.");
-  }
-  if (!dekStore.ragVersion) {
-    throw new Error("RAG Version not found in dekStore. Please upload at least one file with ragIndex: true to initialize RAG.");
   }
-  const ragDEK = unwrapDEK(_clientKEK, dekStore.ragDEK);
-  const { encrypted: encryptedRagDEK, nonce: ragDEKNonce } = encryptPayload(sharedSecret, ragDEK);
-  const { encrypted: encryptedRagVersion, nonce: ragVersionNonce } = encryptPayload(sharedSecret, dekStore.ragVersion);
-  const body = {
-    cipherText: bytesToHex7(cipherText),
-    encryptedParams: bytesToHex7(encrypted),
-    nonce: bytesToHex7(nonce),
-    encryptedDEK: bytesToHex7(encryptedDEK),
-    dekNonce: bytesToHex7(dekNonce),
-    encryptedFileDEKs,
-    encryptedRagDEK: bytesToHex7(encryptedRagDEK),
-    ragDEKNonce: bytesToHex7(ragDEKNonce),
-    encryptedRagVersion: bytesToHex7(encryptedRagVersion),
-    ragVersionNonce: bytesToHex7(ragVersionNonce)
-  };
-  const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
-  return decryptPayload(response.encryptedResponse, sharedSecret, hexToBytes6(response.nonce));
-}
-async function callTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
-  if (FILE_OUTPUT_TOOLS.includes(toolName)) {
-    return callFileOutputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs, attest2);
-  } else if (FILE_INPUT_TOOLS.includes(toolName)) {
-    return callFileInputTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs, attest2);
-  } else if (RAG_TOOLS.includes(toolName)) {
-    return callRagTool(toolName, params, apiKey, dekStore, clientKEK, timeoutMs, attest2);
-  } else {
-    return callSimpleTool(toolName, params, apiKey, timeoutMs, attest2);
+  if (beforeId) {
+    const idx = all.findIndex((m) => m.id === beforeId);
+    if (idx >= 0) {
+      end = idx;
+    }
   }
+  const window = all.slice(start, end);
+  const items = window.slice(0, limit);
+  return { items, hasMore: window.length > items.length };
 }
-function createToolsClient(apiKey, dekStore, clientKEK, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, attest2 = true) {
-  return {
-    generateImage: (params) => callTool("generateImage", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    audioGenerateFromText: (params) => callTool("audioGenerateFromText", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    createFileForUser: (params) => callTool("createFileForUser", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    imageDescribeAndCaption: (params) => callTool("imageDescribeAndCaption", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    imageDescribeAndCaptionFallback: (params) => callTool("imageDescribeAndCaptionFallback", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    videoDescribeAndCaption: (params) => callTool("videoDescribeAndCaption", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getPDFContent: (params) => callTool("getPDFContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getTextDocumentContent: (params) => callTool("getTextDocumentContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    transcribeAudioToText: (params) => callTool("transcribeAudioToText", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    transcribeAudioWithDiarization: (params) => callTool("transcribeAudioWithDiarization", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    audioDiarization: (params) => callTool("audioDiarization", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getFileContentOCR: (params) => callTool("getFileContentOCR", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getSpreadsheetContent: (params) => callTool("getSpreadsheetContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getDataFileContent: (params) => callTool("getDataFileContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getPowerPointContent: (params) => callTool("getPowerPointContent", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    getTime: (params) => callTool("getTime", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    webSearchTool: (params) => callTool("webSearchTool", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    webPageScraperTool: (params) => callTool("webPageScraperTool", params, apiKey, dekStore, clientKEK, timeoutMs, attest2),
-    searchRag: (params) => callTool("searchRag", params, apiKey, dekStore, clientKEK, timeoutMs, attest2)
-  };
-}
-
-// src/core.ts
-async function createRvencClient(options) {
-  const {
-    apiKey,
-    clientKEK,
-    requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
-    maxBufferSize = DEFAULT_MAX_BUFFER_SIZE,
-    attest: attest2 = true
-  } = options;
-  if (options.config?.endpoints !== undefined) {
-    Object.assign(endpoints, options.config.endpoints);
-  }
-  let encryptionKeys;
-  try {
-    encryptionKeys = options.encryptionKeys ?? await generateEncryptionKeys(requestTimeoutMs);
-  } catch (error) {
-    throw new Error(`Failed to initialize encryption keys: ${error instanceof Error ? error.message : error}`);
-  }
-  const dekStore = options.dekStore ?? initializeDEKStore(clientKEK);
-  const client = createRvencChatClient(apiKey, encryptionKeys, requestTimeoutMs, maxBufferSize, attest2, options.config?.openAIClientOptions ?? {});
-  client.files = createFilesClient(apiKey, dekStore, clientKEK, requestTimeoutMs);
-  client.tools = createToolsClient(apiKey, dekStore, clientKEK, requestTimeoutMs, attest2);
-  client.audio = createAudioClient(apiKey, encryptionKeys, requestTimeoutMs, attest2);
-  client.models = createModelsClient(apiKey, requestTimeoutMs);
-  client.dekStore = dekStore;
-  return client;
+function registerAnthropicModelsRoute(router, deps) {
+  router.get("/v1/models", async (req, res) => {
+    const requestId = newAnthropicRequestId();
+    res.setHeader("request-id", requestId);
+    const versionResult = resolveAnthropicVersion(req);
+    if (!versionResult.ok) {
+      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
+    }
+    const apiKey = extractAnthropicApiKey(req);
+    if (!apiKey) {
+      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
+    }
+    try {
+      const client = await deps.getOrCreateClient(apiKey);
+      const type = typeof req.query.type === "string" ? req.query.type : undefined;
+      const all = filterEnabled(await client.models.list({ type })).map(toAnthropicModel);
+      const beforeId = typeof req.query.before_id === "string" ? req.query.before_id : undefined;
+      const afterId = typeof req.query.after_id === "string" ? req.query.after_id : undefined;
+      const limit = parseLimit(req.query.limit);
+      const { items, hasMore } = paginate(all, beforeId, afterId, limit);
+      res.json({
+        data: items,
+        first_id: items.length > 0 ? items[0].id : null,
+        last_id: items.length > 0 ? items[items.length - 1].id : null,
+        has_more: hasMore
+      });
+    } catch (err) {
+      mapUnknownErrorToAnthropicResponse(err, res, requestId);
+    }
+  });
+  router.get("/v1/models/:model_id", async (req, res) => {
+    const requestId = newAnthropicRequestId();
+    res.setHeader("request-id", requestId);
+    const versionResult = resolveAnthropicVersion(req);
+    if (!versionResult.ok) {
+      return sendAnthropicHttpError(res, 400, "invalid_request_error", versionResult.message, requestId);
+    }
+    const apiKey = extractAnthropicApiKey(req);
+    if (!apiKey) {
+      return sendAnthropicHttpError(res, 401, "authentication_error", "Missing x-api-key header (or Authorization with API key).", requestId);
+    }
+    const modelId = req.params.model_id;
+    if (!modelId) {
+      return sendAnthropicHttpError(res, 400, "invalid_request_error", "Missing model id.", requestId);
+    }
+    try {
+      const client = await deps.getOrCreateClient(apiKey);
+      const found = filterEnabled(await client.models.list()).find((m) => m.model === modelId);
+      if (!found) {
+        return sendAnthropicHttpError(res, 404, "not_found_error", `Model "${modelId}" not found.`, requestId);
+      }
+      res.json(toAnthropicModel(found));
+    } catch (err) {
+      mapUnknownErrorToAnthropicResponse(err, res, requestId);
+    }
+  });
 }
-var core_default = createRvencClient;
 
 // src/server/runtime.ts
+import multer from "multer";
 var DEFAULT_HOST = process.env.HOST ?? "127.0.0.1";
 var DEFAULT_PORT = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 8000;
 var CLIENT_CACHE_MAX = (() => {
@@ -2924,36 +2929,23 @@ async function startServer(options = {}) {
 var server_default = createServerApp("both");
 
 // src/cli.ts
-var { values } = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    host: { type: "string", default: "127.0.0.1" },
-    "proxy-url": { type: "string" },
-    "enclave-url": { type: "string" },
-    kek: { type: "string" },
-    port: { type: "string", default: "8000" },
-    "no-attest": { type: "boolean", default: false },
-    compat: { type: "string", default: "openai" },
-    "openai-prefix": { type: "string" },
-    "anthropic-prefix": { type: "string" },
-    "json-body-limit": { type: "string" }
-  },
-  strict: true
-});
-var compat = values.compat;
-if (compat !== "openai" && compat !== "anthropic" && compat !== "both") {
-  console.error(`Invalid --compat "${compat}". Use openai, anthropic, or both.`);
-  process.exit(1);
-}
+var COMPAT_MODES = ["openai", "anthropic", "both"];
+var program = new Command("confidential-proxy").description("end-to-end encrypted OpenAI/Anthropic-compatible proxy").option("--host <host>", "Host to listen on", "127.0.0.1").option("--port <port>", "Port to listen on", (v) => parseInt(v, 10), 8000).option("--proxy-url <url>", "Upstream proxy URL").option("--enclave-url <url>", "Enclave URL").option("--kek <key>", "Client key encryption key", generateNewClientKEK()).option("--no-attest", "Disable enclave attestation").option("--compat <mode>", `Compatibility mode: ${COMPAT_MODES.join(", ")}`, (v) => {
+  if (!COMPAT_MODES.includes(v)) {
+    throw new Error(`Invalid --compat "${v}". Use: ${COMPAT_MODES.join(", ")}.`);
+  }
+  return v;
+}, "openai").option("--openai-prefix <prefix>", "Route prefix for the OpenAI API (used with --compat both)").option("--anthropic-prefix <prefix>", "Route prefix for the Anthropic API (used with --compat both)").option("--json-body-limit <size>", "JSON body size limit (e.g. 64mb)").parse();
+var opts = program.opts();
 startServer({
-  host: values.host,
-  proxyUrl: values["proxy-url"],
-  enclaveUrl: values["enclave-url"],
-  kek: values.kek,
-  port: Number(values.port),
-  attest: !values["no-attest"],
-  compat,
-  openaiRoutePrefix: values["openai-prefix"],
-  anthropicRoutePrefix: values["anthropic-prefix"],
-  jsonBodyLimit: values["json-body-limit"]
+  host: opts.host,
+  port: opts.port,
+  proxyUrl: opts.proxyUrl,
+  enclaveUrl: opts.enclaveUrl,
+  kek: opts.kek,
+  attest: opts.attest,
+  compat: opts.compat,
+  openaiRoutePrefix: opts.openaiPrefix,
+  anthropicRoutePrefix: opts.anthropicPrefix,
+  jsonBodyLimit: opts.jsonBodyLimit
 });