@premai/api-sdk 1.0.41 → 1.0.43

package/dist/index.cjs

@@ -66,6 +66,8 @@ __export(exports_src, {
   startServer: () => startServer,
   serverApp: () => server_default,
   serializeDEKStore: () => serializeDEKStore,
+  resolvePrefixesForCompat: () => resolvePrefixesForCompat,
+  normalizeRoutePrefix: () => normalizeRoutePrefix,
   loadPrem: () => loadPrem,
   isGatewayError: () => isGatewayError,
   isAttestationError: () => isAttestationError,
@@ -77,15 +79,12 @@ __export(exports_src, {
   generateEncryptionKeys: () => generateEncryptionKeys,
   deserializeDEKStore: () => deserializeDEKStore,
   default: () => core_default,
-  createRvencClient: () => createRvencClient
+  createServerApp: () => createServerApp,
+  createRvencClient: () => createRvencClient,
+  DEFAULT_OPENAI_ROUTE_PREFIX_BOTH: () => DEFAULT_OPENAI_ROUTE_PREFIX_BOTH,
+  DEFAULT_ANTHROPIC_ROUTE_PREFIX_BOTH: () => DEFAULT_ANTHROPIC_ROUTE_PREFIX_BOTH
 });
 module.exports = __toCommonJS(exports_src);
-var import_dotenv2 = __toESM(require("dotenv"));
-
-// src/server.ts
-var import_dotenv = __toESM(require("dotenv"));
-var import_express = __toESM(require("express"));
-var import_multer = __toESM(require("multer"));
 
 // src/audio/index.ts
 var import_utils2 = require("@noble/ciphers/utils.js");
@@ -126,25 +125,127 @@ function getGatewayErrorMessage(err) {
     return err.kind.message;
   return null;
 }
-async function attest(apiKey, options = { enabled: true }) {
-  if (!options.enabled)
-    return null;
+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 pruneExpired(now) {
+  for (const [key, entry] of attestCache) {
+    if (entry.expires <= now) {
+      attestCache.delete(key);
+    } else {
+      break;
+    }
+  }
+}
+function isTransientError(err) {
+  const messages = [];
+  if (err instanceof Error) {
+    messages.push(err.message);
+  }
+  if (isAttestationError(err) && Array.isArray(err.cause)) {
+    messages.push(...err.cause);
+  }
+  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;
+  try {
+    obj.free();
+  } catch {}
+}
+async function attemptAttest(apiKey, options) {
   const prem = await loadPrem();
-  const client = await new prem.ClientBuilder(endpoints.proxy ?? "").with_authorization(apiKey).build();
-  let query = new prem.QueryParams;
-  if (options.model)
-    query = query.with("model", options.model);
+  let client;
+  let attested;
+  let headers;
+  let sessionId;
   try {
-    client.set_query(query);
-    const attested = await client.attest();
-    const headers = attested.headers();
-    const sessionId = attested.headers().gpu()?.get("x-session-id") ?? null;
-    headers.free();
-    attested.free();
-    return sessionId;
+    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 {
-    client.free();
+    safeFree(headers);
+    safeFree(attested);
+    safeFree(client);
+  }
+  if (sessionId === null) {
+    throw new Error("missing x-session-id issued by attestation");
   }
+  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));
+    }
+  }
+  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;
+  }
+  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 sessionId;
+  }).finally(() => {
+    attestInflight.delete(key);
+  });
+  attestInflight.set(key, work);
+  return work;
 }
 
 // src/utils/crypto.ts
@@ -1145,10 +1246,14 @@ function createRvencChatClient(apiKey, encryptionKeys, requestTimeoutMs = DEFAUL
       }
       clearTimeout(timeoutId);
       if (isStreaming) {
-        return await postprocessStreamingResponse(response, encryptedRequest.sharedSecret, encryptedRequest.nonce, maxBufferSize);
-      } else {
-        return await postprocessNonStreamingResponse(response, encryptedRequest.sharedSecret);
+        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") {
@@ -1159,6 +1264,39 @@ function createRvencChatClient(apiKey, encryptionKeys, requestTimeoutMs = DEFAUL
   };
   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
+    }
+  }));
+  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
+  };
+}
 async function* createDecryptedStreamGenerator(reader, sharedSecret, nonce, maxBufferSize) {
   const decoder = new TextDecoder;
   let buffer = "";
@@ -1339,7 +1477,7 @@ async function callFileOutputTool(toolName, params, apiKey, dekStore, clientKEK,
   };
   const response = await callToolRequest(toolName, body, apiKey, timeoutMs, attest2);
   const result = await downloadAndDecryptFile(response, dek, apiKey, timeoutMs);
-  if (result && result.fileId) {
+  if (result?.fileId) {
     if (!dekStore.fileDEKs) {
       dekStore.fileDEKs = new Map;
     }
@@ -1396,7 +1534,7 @@ async function callRagTool(toolName, params, apiKey, dekStore, clientKEK, timeou
   }
   const _clientKEK = clientKEK ? import_utils6.hexToBytes(clientKEK) : getClientKEK();
   const encryptedFileDEKs = fileIds.reduce((acc, fileId) => {
-    const fileDEK = dekStore.fileDEKs.get(fileId);
+    const fileDEK = dekStore.fileDEKs?.get(fileId);
     if (!fileDEK) {
       return acc;
     }
@@ -1496,39 +1634,947 @@ async function createRvencClient(options) {
   return client;
 }
 var core_default = createRvencClient;
+// src/server/create-app.ts
+var import_express = __toESM(require("express"));
 
-// src/server.ts
-import_dotenv.default.config();
-var app = import_express.default();
-var HOST = process.env.HOST ?? "127.0.0.1";
-var PORT = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 3000;
-var serverProxyUrl = process.env.PROXY_URL;
-var serverEnclaveUrl = process.env.ENCLAVE_URL;
-var serverKek = process.env.CLIENT_KEK;
-var serverAttest = true;
-app.use(import_express.default.json());
-var storage = import_multer.default.memoryStorage();
-var upload = import_multer.default({
-  storage,
-  limits: {
-    fileSize: 25 * 1024 * 1024
+// src/anthropic/http.ts
+var import_utils7 = require("@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 newAnthropicRequestId() {
+  return `req_${import_utils7.bytesToHex(import_utils7.randomBytes(12))}`;
+}
+function newAnthropicMessageId() {
+  return `msg_${import_utils7.bytesToHex(import_utils7.randomBytes(12))}`;
+}
+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];
   }
-});
-var clientCache = new Map;
-function extractApiKey(req) {
   const authHeader = req.headers.authorization;
   if (!authHeader) {
     return null;
   }
   if (authHeader.startsWith("Bearer ")) {
-    return authHeader.substring(7);
+    return authHeader.slice(7);
   }
   return authHeader;
 }
-async function getOrCreateClient(apiKey) {
-  if (clientCache.has(apiKey)) {
-    return clientCache.get(apiKey);
+function getAnthropicVersionHeader(req) {
+  const raw = req.headers["anthropic-version"];
+  if (typeof raw === "string" && raw.length > 0) {
+    return raw;
+  }
+  if (Array.isArray(raw) && raw[0]) {
+    return raw[0];
+  }
+  return null;
+}
+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 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 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 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 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 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 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 systemToOpenAiMessages(system) {
+  if (typeof system === "string") {
+    if (system.length === 0) {
+      return [];
+    }
+    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.`);
+      }
+    }
+    if (parts.length === 0) {
+      return [];
+    }
+    return [{ role: "system", content: parts.join(`
+
+`) }];
+  }
+  if (system.type === "text" && typeof system.text === "string") {
+    return [{ role: "system", content: system.text }];
+  }
+  throw new AnthropicRequestValidationError("Invalid system parameter shape.");
+}
+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));
+      }
+    }
+    return parts.join(`
+`);
+  }
+  return JSON.stringify(content);
+}
+function anthropicImageBlockToOpenAIPart(part) {
+  const source = part.source;
+  if (!source || typeof source !== "object") {
+    return null;
+  }
+  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 (s.type === "url" && typeof s.url === "string" && s.url.length > 0) {
+    return { type: "image_url", image_url: { url: s.url } };
+  }
+  return null;
+}
+function anthropicUserContentToOpenAIMessages(content) {
+  if (typeof content === "string") {
+    return [{ role: "user", content }];
+  }
+  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)
+      });
+    }
+  }
+  flushParts();
+  return out;
+}
+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
+  };
+  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: {}
+        }
+      }
+    });
+  }
+  return out;
+}
+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}".`);
+  }
+}
+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 = {
+    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.");
+    }
+    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;
+      }
+    }
+  } 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;
+          }
+        }
+      }
+    }
+  }
+  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
+      }
+    });
+  };
+  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;
+      }
+      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);
+    }
+  });
+}
+
+// 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
+  };
+}
+function filterEnabled(models) {
+  return models.filter((m) => m.enabled !== 0);
+}
+function parseLimit(raw) {
+  if (typeof raw !== "string" || raw.length === 0) {
+    return 20;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    return 20;
+  }
+  return Math.min(n, 1000);
+}
+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;
+    }
   }
+  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 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);
+    }
+  });
+}
+
+// src/server/runtime.ts
+var import_multer = __toESM(require("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 = (() => {
+  let cacheTTL = 256;
+  const raw = process.env.CLIENT_CACHE_MAX;
+  if (raw) {
+    const _cacheTTL = Number.parseInt(raw, 10);
+    if (Number.isSafeInteger(_cacheTTL) && _cacheTTL > 0)
+      cacheTTL = _cacheTTL;
+  }
+  return cacheTTL;
+})();
+var serverProxyUrl = process.env.PROXY_URL;
+var serverEnclaveUrl = process.env.ENCLAVE_URL;
+var serverKek = process.env.CLIENT_KEK;
+var serverAttest = true;
+var clientCache = new Map;
+var storage = import_multer.default.memoryStorage();
+var audioUpload = import_multer.default({
+  storage,
+  limits: { fileSize: 25 * 1024 * 1024 }
+});
+function applyServerOptions(options) {
+  const { proxyUrl, enclaveUrl, kek, attest: attest2 } = options;
+  serverAttest = attest2 !== false;
+  if (proxyUrl) {
+    serverProxyUrl = proxyUrl;
+  }
+  if (enclaveUrl) {
+    serverEnclaveUrl = enclaveUrl;
+  }
+  if (kek) {
+    serverKek = kek;
+  }
+}
+async function getOrCreateRvencClient(apiKey) {
+  const existing = clientCache.get(apiKey);
+  if (existing)
+    return existing;
   const client = await core_default({
     apiKey,
     clientKEK: serverKek,
@@ -1541,235 +2587,458 @@ async function getOrCreateClient(apiKey) {
     }
   });
   clientCache.set(apiKey, client);
+  if (clientCache.size > CLIENT_CACHE_MAX) {
+    const oldest = clientCache.keys().next().value;
+    if (oldest !== undefined)
+      clientCache.delete(oldest);
+  }
   return client;
 }
-app.get("/", (_, res) => {
-  res.json({
-    message: "Rvenc OpenAI-compatible API Server",
-    version: "1.0.0",
-    endpoints: {
-      chat_completions: "POST /v1/chat/completions"
+
+// src/openai/routes.ts
+function extractApiKey(req) {
+  const authHeader = req.headers.authorization;
+  if (!authHeader) {
+    return null;
+  }
+  if (authHeader.startsWith("Bearer ")) {
+    return authHeader.slice(7);
+  }
+  return authHeader;
+}
+function sendUnauthorized(res) {
+  res.status(401).json({
+    error: {
+      message: 'Missing Authorization header. Expected format: "Bearer <api-key>" or "<api-key>"',
+      type: "invalid_request_error",
+      code: "invalid_api_key"
     }
   });
-});
-app.post("/v1/chat/completions", async (req, res) => {
-  try {
-    const apiKey = extractApiKey(req);
-    if (!apiKey) {
-      return res.status(401).json({
-        error: {
-          message: 'Missing Authorization header. Expected format: "Bearer <api-key>" or "<api-key>"',
-          type: "invalid_request_error",
-          code: "invalid_api_key"
-        }
-      });
+}
+function sendServerError(res, error) {
+  const err = error;
+  res.status(err.status ?? 500).json({
+    error: {
+      message: err.message ?? "Internal server error",
+      type: err.type ?? "server_error",
+      code: err.code
     }
-    const client = await getOrCreateClient(apiKey);
-    const params = req.body;
-    const completion = await client.chat.completions.create(params);
-    if (params.stream) {
-      res.setHeader("Content-Type", "text/event-stream");
-      res.setHeader("Cache-Control", "no-cache");
-      res.setHeader("Connection", "keep-alive");
-      if (completion && typeof completion === "object" && Symbol.asyncIterator in completion) {
-        try {
-          for await (const chunk of completion) {
-            const data = `data: ${JSON.stringify(chunk)}
+  });
+}
+function openAIOwnedBy(modelId) {
+  const slash = modelId.indexOf("/");
+  if (slash > 0) {
+    return modelId.slice(0, slash);
+  }
+  return "prem";
+}
+function isoToUnix(iso) {
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) {
+    return 0;
+  }
+  return Math.floor(t / 1000);
+}
+function registerOpenAICompatRoutes(router, deps) {
+  router.get("/v1/models", async (req, res) => {
+    try {
+      const apiKey = extractApiKey(req);
+      if (!apiKey) {
+        return sendUnauthorized(res);
+      }
+      const client = await deps.getOrCreateClient(apiKey);
+      const all = await client.models.list();
+      const data = all.filter((m) => m.enabled !== 0).map((m) => ({
+        id: m.model,
+        object: "model",
+        created: isoToUnix(m.created_at),
+        owned_by: openAIOwnedBy(m.model)
+      }));
+      res.json({ object: "list", data });
+    } catch (error) {
+      sendServerError(res, error);
+    }
+  });
+  router.post("/v1/chat/completions", async (req, res) => {
+    try {
+      const apiKey = extractApiKey(req);
+      if (!apiKey) {
+        return sendUnauthorized(res);
+      }
+      const client = await deps.getOrCreateClient(apiKey);
+      const params = req.body;
+      const completion = await client.chat.completions.create(params);
+      if (params.stream) {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        if (completion && typeof completion === "object" && Symbol.asyncIterator in completion) {
+          try {
+            for await (const chunk of completion) {
+              res.write(`data: ${JSON.stringify(chunk)}
 
-`;
-            res.write(data);
-          }
-          res.write(`data: [DONE]
+`);
+            }
+            res.write(`data: [DONE]
 
 `);
-          res.end();
-        } catch (error) {
-          console.error("Streaming error:", error);
-          if (!res.headersSent) {
-            res.status(500).json({
-              error: {
-                message: error.message || "Streaming error",
-                type: "server_error"
-              }
-            });
-          } else {
             res.end();
+          } catch (streamErr) {
+            if (!res.headersSent) {
+              sendServerError(res, streamErr);
+            } else {
+              res.end();
+            }
           }
-        }
-      } else {
-        res.write(`data: ${JSON.stringify(completion)}
+        } else {
+          res.write(`data: ${JSON.stringify(completion)}
 
 `);
-        res.write(`data: [DONE]
+          res.write(`data: [DONE]
 
 `);
-        res.end();
+          res.end();
+        }
+      } else {
+        res.json(completion);
       }
-    } else {
-      res.json(completion);
+    } catch (error) {
+      sendServerError(res, error);
     }
-  } catch (error) {
-    console.error("Chat completions error:", error);
-    const statusCode = error.status || 500;
-    res.status(statusCode).json({
-      error: {
-        message: error.message || "Internal server error",
-        type: error.type || "server_error",
-        code: error.code
+  });
+  router.post("/v1/audio/transcriptions", audioUpload.single("file"), async (req, res) => {
+    try {
+      const apiKey = extractApiKey(req);
+      if (!apiKey) {
+        return sendUnauthorized(res);
       }
-    });
-  }
-});
-app.post("/v1/audio/transcriptions", upload.single("file"), async (req, res) => {
-  try {
-    const apiKey = extractApiKey(req);
-    if (!apiKey) {
-      return res.status(401).json({
-        error: {
-          message: 'Missing Authorization header. Expected format: "Bearer <api-key>" or "<api-key>"',
-          type: "invalid_request_error",
-          code: "invalid_api_key"
-        }
+      if (!req.file) {
+        return res.status(400).json({
+          error: {
+            message: "Missing required file parameter",
+            type: "invalid_request_error"
+          }
+        });
+      }
+      const client = await deps.getOrCreateClient(apiKey);
+      const file = new File([req.file.buffer], req.file.originalname, {
+        type: req.file.mimetype
       });
+      const params = {
+        file,
+        model: req.body.model
+      };
+      if (req.body.language) {
+        params.language = req.body.language;
+      }
+      if (req.body.prompt) {
+        params.prompt = req.body.prompt;
+      }
+      if (req.body.response_format) {
+        params.response_format = req.body.response_format;
+      }
+      if (req.body.temperature) {
+        params.temperature = parseFloat(req.body.temperature);
+      }
+      if (req.body.timestamp_granularities) {
+        params.timestamp_granularities = Array.isArray(req.body.timestamp_granularities) ? req.body.timestamp_granularities : JSON.parse(req.body.timestamp_granularities);
+      }
+      const transcription = await client.audio.transcriptions.create(params);
+      res.json(transcription);
+    } catch (error) {
+      sendServerError(res, error);
     }
-    if (!req.file) {
-      return res.status(400).json({
-        error: {
-          message: "Missing required file parameter",
-          type: "invalid_request_error"
-        }
+  });
+  router.post("/v1/audio/translations", audioUpload.single("file"), async (req, res) => {
+    try {
+      const apiKey = extractApiKey(req);
+      if (!apiKey) {
+        return sendUnauthorized(res);
+      }
+      if (!req.file) {
+        return res.status(400).json({
+          error: {
+            message: "Missing required file parameter",
+            type: "invalid_request_error"
+          }
+        });
+      }
+      const client = await deps.getOrCreateClient(apiKey);
+      const file = new File([req.file.buffer], req.file.originalname, {
+        type: req.file.mimetype
       });
+      const params = {
+        file,
+        model: req.body.model
+      };
+      if (req.body.prompt) {
+        params.prompt = req.body.prompt;
+      }
+      if (req.body.response_format) {
+        params.response_format = req.body.response_format;
+      }
+      if (req.body.temperature) {
+        params.temperature = parseFloat(req.body.temperature);
+      }
+      const translation = await client.audio.translations.create(params);
+      res.json(translation);
+    } catch (error) {
+      sendServerError(res, error);
+    }
+  });
+}
+
+// src/server/route-prefix.ts
+function normalizeRoutePrefix(raw) {
+  if (raw == null) {
+    return "";
+  }
+  return new URL(String(raw).trim(), "http://localhost").pathname || "";
+}
+var DEFAULT_OPENAI_ROUTE_PREFIX_BOTH = "/openai";
+var DEFAULT_ANTHROPIC_ROUTE_PREFIX_BOTH = "/anthropic";
+function resolvePrefixesForCompat(compat, openaiRaw, anthropicRaw) {
+  const oNorm = normalizeRoutePrefix(openaiRaw);
+  const aNorm = normalizeRoutePrefix(anthropicRaw);
+  if (compat === "both") {
+    const openaiPrefix = oNorm || DEFAULT_OPENAI_ROUTE_PREFIX_BOTH;
+    const anthropicPrefix = aNorm || DEFAULT_ANTHROPIC_ROUTE_PREFIX_BOTH;
+    if (openaiPrefix === anthropicPrefix) {
+      throw new Error(`When compat is "both", openaiRoutePrefix and anthropicRoutePrefix must differ (both resolved to "${openaiPrefix}").`);
+    }
+    return { openaiPrefix, anthropicPrefix };
+  }
+  if (compat === "openai") {
+    return { openaiPrefix: oNorm, anthropicPrefix: "" };
+  }
+  return { openaiPrefix: "", anthropicPrefix: aNorm };
+}
+function prefixedRoute(prefix, path) {
+  const s = path.startsWith("/") ? path : `/${path}`;
+  if (!prefix) {
+    return s;
+  }
+  return `${prefix}${s}`;
+}
+
+// src/server/discovery.ts
+function registerApiDiscoveryRoute(app, mount) {
+  const {
+    openai: mountOpenAI,
+    anthropic: mountAnthropic,
+    openaiPrefix,
+    anthropicPrefix
+  } = mount;
+  app.get("/", (_, res) => {
+    const endpoints2 = {};
+    if (mountOpenAI) {
+      endpoints2.chat_completions = `POST ${prefixedRoute(openaiPrefix, "/v1/chat/completions")}`;
+      endpoints2.audio_transcriptions = `POST ${prefixedRoute(openaiPrefix, "/v1/audio/transcriptions")}`;
+      endpoints2.audio_translations = `POST ${prefixedRoute(openaiPrefix, "/v1/audio/translations")}`;
+      endpoints2.models = `GET ${prefixedRoute(openaiPrefix, "/v1/models")}`;
     }
-    const client = await getOrCreateClient(apiKey);
-    const file = new File([req.file.buffer], req.file.originalname, {
-      type: req.file.mimetype
+    if (mountAnthropic) {
+      endpoints2.messages = `POST ${prefixedRoute(anthropicPrefix, "/v1/messages")}`;
+      endpoints2.messages_count_tokens = `POST ${prefixedRoute(anthropicPrefix, "/v1/messages/count_tokens")}`;
+      endpoints2.anthropic_models = `GET ${prefixedRoute(anthropicPrefix, "/v1/models")}`;
+      endpoints2.anthropic_model_get = `GET ${prefixedRoute(anthropicPrefix, "/v1/models/{model_id}")}`;
+    }
+    const labels = [];
+    if (mountOpenAI) {
+      labels.push("OpenAI-compatible");
+    }
+    if (mountAnthropic) {
+      labels.push("Anthropic Messages-compatible");
+    }
+    res.json({
+      message: `Rvenc API Server (${labels.join(" + ")})`,
+      version: "1.0.0",
+      compat: resolveCompatLabel(mount),
+      route_prefixes: buildRoutePrefixesPayload(mountOpenAI, mountAnthropic, openaiPrefix, anthropicPrefix),
+      endpoints: endpoints2
     });
-    const params = {
-      file,
-      model: req.body.model
+  });
+}
+function buildRoutePrefixesPayload(mountOpenAI, mountAnthropic, openaiPrefix, anthropicPrefix) {
+  const out = {};
+  if (mountOpenAI) {
+    out.openai = openaiPrefix || "/";
+  }
+  if (mountAnthropic) {
+    out.anthropic = anthropicPrefix || "/";
+  }
+  if (Object.keys(out).length === 0) {
+    return;
+  }
+  return out;
+}
+function resolveCompatLabel(mount) {
+  if (mount.openai && mount.anthropic) {
+    return "both";
+  }
+  if (mount.anthropic) {
+    return "anthropic";
+  }
+  return "openai";
+}
+
+// src/server/create-app.ts
+var rvencDeps = {
+  getOrCreateClient: getOrCreateRvencClient
+};
+function resolveJsonBodyLimit(override) {
+  if (override != null && String(override).trim() !== "") {
+    return String(override).trim();
+  }
+  const env = process.env.JSON_BODY_LIMIT;
+  if (env != null && env !== "") {
+    return env;
+  }
+  return "32mb";
+}
+function resolveCreateServerInput(compatOrOptions) {
+  if (typeof compatOrOptions === "string") {
+    const compat2 = compatOrOptions;
+    const { openaiPrefix: openaiPrefix2, anthropicPrefix: anthropicPrefix2 } = resolvePrefixesForCompat(compat2, undefined, undefined);
+    return {
+      compat: compat2,
+      openaiPrefix: openaiPrefix2,
+      anthropicPrefix: anthropicPrefix2,
+      jsonBodyLimit: resolveJsonBodyLimit()
     };
-    if (req.body.language)
-      params.language = req.body.language;
-    if (req.body.prompt)
-      params.prompt = req.body.prompt;
-    if (req.body.response_format)
-      params.response_format = req.body.response_format;
-    if (req.body.temperature)
-      params.temperature = parseFloat(req.body.temperature);
-    if (req.body.timestamp_granularities) {
-      params.timestamp_granularities = Array.isArray(req.body.timestamp_granularities) ? req.body.timestamp_granularities : JSON.parse(req.body.timestamp_granularities);
-    }
-    const transcription = await client.audio.transcriptions.create(params);
-    res.json(transcription);
-  } catch (error) {
-    console.error("Audio transcription error:", error);
-    const statusCode = error.status || 500;
-    res.status(statusCode).json({
-      error: {
-        message: error.message || "Internal server error",
-        type: error.type || "server_error",
-        code: error.code
-      }
-    });
   }
-});
-app.post("/v1/audio/translations", upload.single("file"), async (req, res) => {
-  try {
-    const apiKey = extractApiKey(req);
-    if (!apiKey) {
-      return res.status(401).json({
-        error: {
-          message: 'Missing Authorization header. Expected format: "Bearer <api-key>" or "<api-key>"',
-          type: "invalid_request_error",
-          code: "invalid_api_key"
-        }
-      });
+  const compat = compatOrOptions.compat ?? "openai";
+  const { openaiPrefix, anthropicPrefix } = resolvePrefixesForCompat(compat, compatOrOptions.openaiRoutePrefix, compatOrOptions.anthropicRoutePrefix);
+  return {
+    compat,
+    openaiPrefix,
+    anthropicPrefix,
+    jsonBodyLimit: resolveJsonBodyLimit(compatOrOptions.jsonBodyLimit)
+  };
+}
+function httpErrorStatus(err) {
+  if (err && typeof err === "object") {
+    const o = err;
+    const s = o.status ?? o.statusCode;
+    if (typeof s === "number" && s >= 400 && s < 600) {
+      return s;
     }
-    if (!req.file) {
-      return res.status(400).json({
+  }
+  return 500;
+}
+function mountRouter(app, prefix, router) {
+  app.use(prefix || "/", router);
+}
+function createServerApp(compatOrOptions = "openai") {
+  const { compat, openaiPrefix, anthropicPrefix, jsonBodyLimit } = resolveCreateServerInput(compatOrOptions);
+  const mountOpenAI = compat === "openai" || compat === "both";
+  const mountAnthropic = compat === "anthropic" || compat === "both";
+  const app = import_express.default();
+  app.use(import_express.default.json({ limit: jsonBodyLimit }));
+  registerApiDiscoveryRoute(app, {
+    openai: mountOpenAI,
+    anthropic: mountAnthropic,
+    openaiPrefix,
+    anthropicPrefix
+  });
+  if (mountOpenAI) {
+    const router = import_express.default.Router();
+    registerOpenAICompatRoutes(router, rvencDeps);
+    mountRouter(app, openaiPrefix, router);
+  }
+  if (mountAnthropic) {
+    const router = import_express.default.Router();
+    registerAnthropicMessagesRoute(router, rvencDeps);
+    registerAnthropicCountTokensRoute(router, rvencDeps);
+    registerAnthropicModelsRoute(router, rvencDeps);
+    mountRouter(app, anthropicPrefix, router);
+  }
+  const isAnthropicRequest = (req) => {
+    if (!mountAnthropic) {
+      return false;
+    }
+    if (!mountOpenAI) {
+      return true;
+    }
+    return req.path === anthropicPrefix || req.path.startsWith(`${anthropicPrefix}/`);
+  };
+  app.use((err, req, res, _next) => {
+    const status = httpErrorStatus(err);
+    const message = err instanceof Error ? err.message : "Internal server error";
+    if (isAnthropicRequest(req)) {
+      const requestId = newAnthropicRequestId();
+      res.setHeader("request-id", requestId);
+      res.status(status).json({
+        type: "error",
         error: {
-          message: "Missing required file parameter",
-          type: "invalid_request_error"
-        }
+          type: httpStatusToAnthropicErrorType(status),
+          message
+        },
+        request_id: requestId
       });
+      return;
     }
-    const client = await getOrCreateClient(apiKey);
-    const file = new File([req.file.buffer], req.file.originalname, {
-      type: req.file.mimetype
-    });
-    const params = {
-      file,
-      model: req.body.model
-    };
-    if (req.body.prompt)
-      params.prompt = req.body.prompt;
-    if (req.body.response_format)
-      params.response_format = req.body.response_format;
-    if (req.body.temperature)
-      params.temperature = parseFloat(req.body.temperature);
-    const translation = await client.audio.translations.create(params);
-    res.json(translation);
-  } catch (error) {
-    console.error("Audio translation error:", error);
-    const statusCode = error.status || 500;
-    res.status(statusCode).json({
+    res.status(status).json({
       error: {
-        message: error.message || "Internal server error",
-        type: error.type || "server_error",
-        code: error.code
+        message,
+        type: "server_error"
       }
     });
-  }
-});
-app.use((err, _req, res, _next) => {
-  console.error(`Unhandled error: ${err}`);
-  res.status(500).json({
-    error: {
-      message: err.message || "Internal server error",
-      type: "server_error"
-    }
   });
-});
-app.use((req, res) => {
-  res.status(404).json({
-    error: {
-      message: `Route ${req.method} ${req.path} not found`,
-      type: "invalid_request_error"
+  app.use((req, res) => {
+    const message = `Route ${req.method} ${req.path} not found`;
+    if (isAnthropicRequest(req)) {
+      const requestId = newAnthropicRequestId();
+      res.setHeader("request-id", requestId);
+      res.status(404).json({
+        type: "error",
+        error: { type: "not_found_error", message },
+        request_id: requestId
+      });
+      return;
     }
+    res.status(404).json({
+      error: {
+        message,
+        type: "invalid_request_error"
+      }
+    });
   });
-});
+  return app;
+}
+// src/server/start.ts
 async function startServer(options = {}) {
-  const { host, port, proxyUrl, enclaveUrl, kek, attest: attest2 } = options;
-  const serverHost = host || HOST;
-  const serverPort = port || PORT;
-  serverAttest = attest2 !== false;
-  if (proxyUrl) {
-    serverProxyUrl = proxyUrl;
-  }
-  if (enclaveUrl) {
-    serverEnclaveUrl = enclaveUrl;
-  }
-  if (kek) {
-    serverKek = kek;
-  }
+  const {
+    host,
+    port,
+    compat: compatOpt,
+    openaiRoutePrefix,
+    anthropicRoutePrefix,
+    jsonBodyLimit
+  } = options;
+  const serverHost = host || DEFAULT_HOST;
+  const serverPort = port || DEFAULT_PORT;
+  const compat = compatOpt ?? "openai";
+  applyServerOptions(options);
+  resolvePrefixesForCompat(compat, openaiRoutePrefix, anthropicRoutePrefix);
+  const app = createServerApp({
+    compat,
+    openaiRoutePrefix,
+    anthropicRoutePrefix,
+    jsonBodyLimit
+  });
   return new Promise((resolve, reject) => {
     const server = app.listen(serverPort, serverHost, () => {
-      console.log(`
-Rvenc Server running on http://${serverHost}:${serverPort}`);
-      resolve();
+      resolve({ close: () => server.close() });
     });
     server.on("error", (error) => {
-      if (error.code === "EADDRINUSE") {
-        console.error(`❌ Port ${serverPort} is already in use`);
+      if (error && typeof error === "object" && "code" in error && error.code === "EADDRINUSE") {
+        reject(new Error(`Port ${serverPort} is already in use`));
       } else {
-        console.error(`❌ Failed to start server: ${error}`);
+        reject(error);
       }
-      reject(error);
     });
   });
 }
-if (false) {}
-var server_default = app;
-
-// src/index.ts
-import_dotenv2.default.config();
+// src/server.ts
+var server_default = createServerApp("both");