@tonyclaw/llm-inspector 1.6.0

package/.output/server/_ssr/router-Bq_mxeNz.mjs

@@ -0,0 +1,2872 @@
+import { c as createRouter, a as createRootRoute, b as createFileRoute, l as lazyRouteComponent, O as Outlet, H as HeadContent, S as Scripts } from "../_libs/tanstack__react-router.mjs";
+import { j as jsxRuntimeExports } from "../_libs/react.mjs";
+import { mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, existsSync, readFileSync } from "node:fs";
+import path, { join, dirname, isAbsolute } from "node:path";
+import { readFile, mkdir, writeFile, appendFile } from "node:fs/promises";
+import { C as Conf } from "../_libs/conf.mjs";
+import { randomUUID } from "crypto";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { o as object, _ as _enum, s as string, a as array, n as number, d as discriminatedUnion, l as literal, b as boolean, r as record, c as lazy, e as _null, u as union } from "../_libs/zod.mjs";
+import "../_libs/tiny-warning.mjs";
+import "../_libs/tanstack__router-core.mjs";
+import "../_libs/cookie-es.mjs";
+import "../_libs/tanstack__history.mjs";
+import "../_libs/tiny-invariant.mjs";
+import "../_libs/seroval.mjs";
+import "../_libs/seroval-plugins.mjs";
+import "node:stream/web";
+import "node:stream";
+import "../_libs/react-dom.mjs";
+import "../_libs/isbot.mjs";
+import "node:process";
+import "node:crypto";
+import "node:assert";
+import "../_libs/dot-prop.mjs";
+import "../_libs/env-paths.mjs";
+import "node:os";
+import "../_libs/atomically.mjs";
+import "../_libs/stubborn-fs.mjs";
+import "../_libs/stubborn-utils.mjs";
+import "../_libs/when-exit.mjs";
+import "../_libs/ajv.mjs";
+import "../_libs/fast-deep-equal.mjs";
+import "../_libs/json-schema-traverse.mjs";
+import "../_libs/fast-uri.mjs";
+import "../_libs/ajv-formats.mjs";
+import "../_libs/debounce-fn.mjs";
+import "../_libs/mimic-function.mjs";
+import "../_libs/semver.mjs";
+import "../_libs/uint8array-extras.mjs";
+const appCss = "/assets/index-B3RwBPLW.css";
+const Route$e = createRootRoute({
+  head: () => ({
+    meta: [
+      { charSet: "utf-8" },
+      { name: "viewport", content: "width=device-width, initial-scale=1" },
+      { title: "llm-inspector" }
+    ],
+    links: [{ rel: "stylesheet", href: appCss }]
+  }),
+  component: RootComponent
+});
+function RootComponent() {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(RootDocument, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(Outlet, {}) });
+}
+function RootDocument({ children }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("html", { lang: "en", className: "dark", children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("head", { children: /* @__PURE__ */ jsxRuntimeExports.jsx(HeadContent, {}) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("body", { children: [
+      children,
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Scripts, {})
+    ] })
+  ] });
+}
+const $$splitComponentImporter = () => import("./index-ByCLZu7J.mjs");
+const Route$d = createFileRoute("/")({
+  component: lazyRouteComponent($$splitComponentImporter, "component")
+});
+const LOG_DIR_ENV = process.env["LOG_DIR"];
+Number(process.env["LOG_RETENTION_DAYS"] ?? "7");
+function getUserDataDir() {
+  if (process.platform === "win32") {
+    return process.env["APPDATA"] ?? path.join(process.env["USERPROFILE"] ?? "C:\\", ".llm-inspector");
+  }
+  return process.env["HOME"] ?? path.join("/tmp");
+}
+let resolvedLogDir = null;
+function resolveLogDir() {
+  if (resolvedLogDir !== null) return resolvedLogDir;
+  const base = getUserDataDir();
+  if (LOG_DIR_ENV !== void 0) {
+    resolvedLogDir = path.isAbsolute(LOG_DIR_ENV) ? LOG_DIR_ENV : path.join(base, LOG_DIR_ENV);
+  } else {
+    resolvedLogDir = path.join(base, ".llm-inspector", "logs");
+  }
+  return resolvedLogDir;
+}
+function getLogFilePath() {
+  const date = /* @__PURE__ */ new Date();
+  const yyyy = date.getUTCFullYear();
+  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(date.getUTCDate()).padStart(2, "0");
+  return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
+}
+let writeBuffer = [];
+let writeScheduled = false;
+async function flushWriteBuffer() {
+  if (writeBuffer.length === 0) return;
+  const toWrite = writeBuffer.join("");
+  writeBuffer = [];
+  try {
+    const filePath = getLogFilePath();
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await appendFile(filePath, toWrite, "utf-8");
+  } catch (err) {
+    console.error("[logger] Failed to write log entries:", err);
+  }
+}
+function scheduleFlush() {
+  if (writeScheduled) return;
+  writeScheduled = true;
+  void Promise.resolve().then(() => {
+    writeScheduled = false;
+    void flushWriteBuffer();
+  });
+}
+function appendLogEntry(entry) {
+  const line = JSON.stringify(entry) + "\n";
+  writeBuffer.push(line);
+  scheduleFlush();
+}
+const INDEX_VERSION = 1;
+const INDEX_FILE = "logs.idx";
+function getIndexPath() {
+  return join(resolveLogDir(), INDEX_FILE);
+}
+let cachedIndex = null;
+function createEmptyIndex() {
+  return {
+    version: INDEX_VERSION,
+    entries: {},
+    maxId: 0
+  };
+}
+function isLogIndex(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
+  const versionDesc = Object.getOwnPropertyDescriptor(obj, "version");
+  const entriesDesc = Object.getOwnPropertyDescriptor(obj, "entries");
+  const maxIdDesc = Object.getOwnPropertyDescriptor(obj, "maxId");
+  return versionDesc !== void 0 && typeof versionDesc.value === "number" && entriesDesc !== void 0 && typeof entriesDesc.value === "object" && entriesDesc.value !== null && maxIdDesc !== void 0 && typeof maxIdDesc.value === "number";
+}
+async function loadIndex() {
+  if (cachedIndex !== null) return cachedIndex;
+  const indexPath = getIndexPath();
+  if (!existsSync(indexPath)) {
+    cachedIndex = createEmptyIndex();
+    return cachedIndex;
+  }
+  try {
+    const content = await readFile(indexPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (isLogIndex(parsed)) {
+      cachedIndex = parsed;
+    } else {
+      cachedIndex = createEmptyIndex();
+    }
+    return cachedIndex;
+  } catch (err) {
+    console.error("[logIndex] Failed to load index:", err);
+    cachedIndex = createEmptyIndex();
+    return cachedIndex;
+  }
+}
+async function saveIndex(index) {
+  const indexPath = getIndexPath();
+  const dir = dirname(indexPath);
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch {
+  }
+  try {
+    await writeFile(indexPath, JSON.stringify(index), "utf-8");
+  } catch (err) {
+    console.error("[logIndex] Failed to save index:", err);
+  }
+}
+async function addToIndex(id, file, lineStart, lineEnd) {
+  const index = await loadIndex();
+  index.entries[id] = { id, file, lineStart, lineEnd };
+  if (id > index.maxId) {
+    index.maxId = id;
+  }
+  await saveIndex(index);
+}
+async function findInIndex(id) {
+  const index = await loadIndex();
+  return index.entries[id] ?? null;
+}
+async function getNextLogId() {
+  const index = await loadIndex();
+  return index.maxId + 1;
+}
+function getCurrentLogFile() {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(now.getUTCDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}.jsonl`;
+}
+const JsonValueSchema = lazy(
+  () => union([
+    string(),
+    number(),
+    boolean(),
+    _null(),
+    array(JsonValueSchema),
+    record(string(), JsonValueSchema)
+  ])
+);
+const CacheControl = object({
+  type: string(),
+  ttl: string().optional(),
+  scope: string().optional()
+});
+const TextContentBlock = object({
+  type: literal("text"),
+  text: string(),
+  cache_control: CacheControl.optional()
+});
+const ThinkingContentBlock = object({
+  type: literal("thinking"),
+  thinking: string(),
+  signature: string().optional()
+});
+const ImageSourceBlock = object({
+  type: literal("base64"),
+  media_type: string(),
+  data: string()
+});
+const ImageContentBlock = object({
+  type: literal("image"),
+  source: ImageSourceBlock
+});
+const ToolUseContentBlock = object({
+  type: literal("tool_use"),
+  id: string(),
+  name: string(),
+  input: record(string(), JsonValueSchema)
+});
+const ToolResultContentItem = discriminatedUnion("type", [TextContentBlock, ImageContentBlock]);
+const ToolResultContentBlock = object({
+  type: literal("tool_result"),
+  tool_use_id: string().optional(),
+  content: union([string(), array(ToolResultContentItem)]),
+  is_error: boolean().optional()
+});
+const ContentBlock = discriminatedUnion("type", [
+  TextContentBlock,
+  ThinkingContentBlock,
+  ImageContentBlock,
+  ToolUseContentBlock,
+  ToolResultContentBlock
+]);
+const MessageContent = union([string(), array(ContentBlock)]);
+const Message = object({
+  role: _enum(["user", "assistant"]),
+  content: MessageContent
+});
+const SystemBlock = object({
+  type: literal("text"),
+  text: string(),
+  cache_control: CacheControl.optional()
+});
+const InputSchema = object({
+  type: string(),
+  properties: record(string(), record(string(), JsonValueSchema)).optional(),
+  required: array(string()).optional(),
+  additionalProperties: boolean().optional(),
+  $schema: string().optional()
+});
+const ToolDefinition = object({
+  name: string(),
+  description: string().optional(),
+  input_schema: InputSchema.optional(),
+  cache_control: CacheControl.optional()
+});
+const ThinkingConfig = discriminatedUnion("type", [
+  object({ type: literal("enabled"), budget_tokens: number() }),
+  object({ type: literal("disabled") }),
+  object({ type: literal("adaptive") })
+]);
+const AnthropicRequestSchema = object({
+  model: string(),
+  messages: array(Message),
+  system: array(SystemBlock).optional(),
+  tools: array(ToolDefinition).optional(),
+  max_tokens: number().optional(),
+  temperature: number().optional(),
+  stream: boolean().optional(),
+  thinking: ThinkingConfig.optional(),
+  metadata: object({
+    user_id: string().optional()
+  }).optional()
+});
+const ResponseContentBlock = discriminatedUnion("type", [
+  TextContentBlock,
+  ThinkingContentBlock,
+  ToolUseContentBlock
+]);
+const ResponseUsageSchema = object({
+  input_tokens: number(),
+  output_tokens: number(),
+  cache_creation_input_tokens: number().optional(),
+  cache_read_input_tokens: number().optional()
+});
+const AnthropicResponseSchema$1 = object({
+  id: string(),
+  type: literal("message"),
+  model: string(),
+  role: literal("assistant"),
+  content: array(ResponseContentBlock),
+  stop_reason: string().nullable(),
+  stop_sequence: string().nullable(),
+  usage: ResponseUsageSchema
+});
+const SseMessageStartEvent = object({
+  type: literal("message_start"),
+  message: object({
+    id: string(),
+    type: literal("message"),
+    model: string(),
+    role: literal("assistant"),
+    content: array(ResponseContentBlock),
+    stop_reason: _null(),
+    stop_sequence: _null(),
+    usage: object({
+      input_tokens: number(),
+      cache_creation_input_tokens: number().optional(),
+      cache_read_input_tokens: number().optional()
+    }).passthrough()
+  })
+});
+const SseContentBlockStartEvent = object({
+  type: literal("content_block_start"),
+  index: number(),
+  content_block: ResponseContentBlock
+});
+const SseDeltaBlock = discriminatedUnion("type", [
+  object({ type: literal("text_delta"), text: string() }),
+  object({ type: literal("input_json_delta"), partial_json: string() }),
+  object({ type: literal("thinking_delta"), thinking: string() }),
+  object({ type: literal("signature_delta"), signature: string() })
+]);
+const SseContentBlockDeltaEvent = object({
+  type: literal("content_block_delta"),
+  index: number(),
+  delta: SseDeltaBlock
+});
+const SseContentBlockStopEvent = object({
+  type: literal("content_block_stop"),
+  index: number()
+});
+const SseMessageDeltaEvent = object({
+  type: literal("message_delta"),
+  delta: object({
+    stop_reason: string().nullable(),
+    stop_sequence: string().nullable().optional()
+  }),
+  usage: object({
+    output_tokens: number(),
+    input_tokens: number().optional(),
+    cache_creation_input_tokens: number().optional(),
+    cache_read_input_tokens: number().optional()
+  }).passthrough()
+});
+const SseMessageStopEvent = object({
+  type: literal("message_stop")
+});
+const SsePingEvent = object({
+  type: literal("ping")
+});
+const SseEventSchema = discriminatedUnion("type", [
+  SseMessageStartEvent,
+  SseContentBlockStartEvent,
+  SseContentBlockDeltaEvent,
+  SseContentBlockStopEvent,
+  SseMessageDeltaEvent,
+  SseMessageStopEvent,
+  SsePingEvent
+]);
+const InspectorRequestSchema = AnthropicRequestSchema;
+const InspectorResponseSchema = AnthropicResponseSchema$1;
+const OpenAIMessageContent = union([
+  string(),
+  array(
+    discriminatedUnion("type", [
+      object({ type: literal("text"), text: string() }),
+      object({
+        type: literal("image_url"),
+        image_url: object({ url: string(), detail: string().optional() })
+      })
+    ])
+  )
+]);
+const OpenAIMessage = object({
+  role: _enum(["system", "user", "assistant", "tool"]),
+  content: OpenAIMessageContent,
+  name: string().optional(),
+  reasoning_content: string().optional()
+});
+const OpenAIFunctionCall = object({
+  name: string(),
+  arguments: string()
+});
+OpenAIMessage.extend({
+  content: union([string(), array(object({ type: literal("text"), text: string() }))]).optional(),
+  function_call: OpenAIFunctionCall.optional()
+});
+const OpenAIToolDefinition = object({
+  type: literal("function"),
+  function: object({
+    name: string(),
+    description: string().optional(),
+    parameters: record(string(), JsonValueSchema)
+  })
+});
+const OpenAIRequestSchema = object({
+  model: string(),
+  messages: array(OpenAIMessage),
+  temperature: number().optional(),
+  max_tokens: number().optional(),
+  stream: boolean().optional(),
+  tools: array(OpenAIToolDefinition).optional(),
+  tool_choice: union([
+    object({ type: literal("auto") }),
+    object({ type: literal("none") }),
+    object({ type: literal("function"), function: object({ name: string() }) })
+  ]).optional(),
+  user: string().optional()
+});
+const OpenAIChoiceDelta = object({
+  role: _enum(["assistant"]).optional(),
+  content: string().nullable().optional(),
+  reasoning_content: string().nullable().optional(),
+  function_call: object({ name: string().optional(), arguments: string().optional() }).optional(),
+  tool_calls: array(
+    object({
+      index: number(),
+      id: string().optional(),
+      type: literal("function").optional(),
+      function: object({
+        name: string().optional(),
+        arguments: string().optional()
+      })
+    })
+  ).optional()
+});
+const OpenAIChoice = object({
+  index: number(),
+  message: object({
+    role: _enum(["assistant"]),
+    content: string().nullable(),
+    reasoning_content: string().optional(),
+    function_call: object({ name: string(), arguments: string() }).optional()
+  }).optional(),
+  delta: OpenAIChoiceDelta.optional(),
+  finish_reason: string().nullable()
+});
+const OpenAIResponseSchema$1 = object({
+  id: string(),
+  object: literal("chat.completion"),
+  created: number(),
+  model: string(),
+  choices: array(OpenAIChoice),
+  usage: object({
+    prompt_tokens: number(),
+    completion_tokens: number(),
+    total_tokens: number()
+  })
+});
+const OpenAISSERawChunkSchema = object({
+  id: string(),
+  object: literal("chat.completion.chunk"),
+  created: number(),
+  model: string(),
+  choices: array(
+    object({
+      index: number(),
+      delta: OpenAIChoiceDelta,
+      finish_reason: string().nullable().optional()
+    })
+  ),
+  usage: object({
+    prompt_tokens: number(),
+    completion_tokens: number(),
+    total_tokens: number()
+  }).nullable().optional()
+});
+function parseOpenAIResponse(rawBody) {
+  try {
+    const json = JSON.parse(rawBody);
+    const result = OpenAIResponseSchema$1.safeParse(json);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+const StreamingChunkSchema$1 = object({
+  index: number(),
+  timestamp: number(),
+  type: string(),
+  data: JsonValueSchema
+});
+const StreamingChunksArraySchema = object({
+  chunks: array(StreamingChunkSchema$1),
+  truncated: boolean().optional().default(false)
+});
+const CapturedLogSchema = object({
+  id: number(),
+  timestamp: string(),
+  method: string(),
+  path: string(),
+  model: string().nullable(),
+  sessionId: string().nullable(),
+  rawRequestBody: string().nullable(),
+  responseStatus: number().nullable(),
+  responseText: string().nullable(),
+  inputTokens: number().nullable(),
+  outputTokens: number().nullable(),
+  cacheCreationInputTokens: number().nullable(),
+  cacheReadInputTokens: number().nullable(),
+  elapsedMs: number().nullable(),
+  streaming: boolean(),
+  userAgent: string().nullable(),
+  origin: string().nullable(),
+  rawHeaders: record(string(), string()).optional(),
+  /** Headers sent to the upstream LLM */
+  headers: record(string(), string()).optional(),
+  apiFormat: _enum(["anthropic", "openai", "unknown"]).default("unknown"),
+  isTest: boolean().optional().default(false),
+  providerName: string().nullable().optional(),
+  clientPort: number().nullable().optional(),
+  clientPid: number().nullable().optional(),
+  clientCwd: string().nullable().optional(),
+  clientProjectFolder: string().nullable().optional(),
+  streamingChunks: StreamingChunksArraySchema.optional(),
+  streamingChunksPath: string().nullable().optional()
+});
+const RequestModelSchema = object({
+  model: string()
+});
+function extractModelFromBody(body) {
+  try {
+    const json = JSON.parse(body);
+    const parsed = RequestModelSchema.safeParse(json);
+    if (parsed.success) {
+      return parsed.data.model;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseRequest(rawBody) {
+  if (rawBody === null) return null;
+  try {
+    const json = JSON.parse(rawBody);
+    const result = InspectorRequestSchema.safeParse(json);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+const StreamingChunkSchema = object({
+  index: number(),
+  timestamp: number(),
+  type: string(),
+  data: JsonValueSchema
+});
+const StreamingChunksDataSchema = object({
+  chunks: array(StreamingChunkSchema),
+  truncated: boolean().optional()
+});
+const CHUNKS_DIR_ENV = process.env["CHUNKS_DIR"];
+function getChunksDir() {
+  const isWindows = process.platform === "win32";
+  const base = isWindows ? process.env["APPDATA"] ?? join(process.env["USERPROFILE"] ?? "C:\\", ".llm-inspector") : process.env["HOME"] ?? "/tmp";
+  if (CHUNKS_DIR_ENV !== void 0) {
+    return isAbsolute(CHUNKS_DIR_ENV) ? CHUNKS_DIR_ENV : join(base, CHUNKS_DIR_ENV);
+  }
+  return join(base, ".llm-inspector", "chunks");
+}
+function getChunkFilePath(logId) {
+  return join(getChunksDir(), `${logId}.json`);
+}
+function getTempFilePath(logId) {
+  return join(getChunksDir(), `.${logId}.tmp`);
+}
+function writeChunks(logId, chunks, truncated) {
+  const dir = getChunksDir();
+  const targetPath = getChunkFilePath(logId);
+  const tempPath = getTempFilePath(logId);
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    console.error("[chunkStorage] Failed to create chunks directory:", err);
+  }
+  const data = { chunks, truncated };
+  try {
+    writeFileSync(tempPath, JSON.stringify(data), "utf-8");
+  } catch (err) {
+    console.error("[chunkStorage] Failed to write chunks temp file:", err);
+    return targetPath;
+  }
+  try {
+    renameSync(tempPath, targetPath);
+  } catch (err) {
+    console.warn("[chunkStorage] Rename failed, falling back to copy+delete:", err);
+    try {
+      copyFileSync(tempPath, targetPath);
+      unlinkSync(tempPath);
+    } catch (copyErr) {
+      console.error("[chunkStorage] Failed to copy chunks file:", copyErr);
+    }
+  }
+  return targetPath;
+}
+function readChunks(path2) {
+  if (!existsSync(path2)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path2, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = StreamingChunksDataSchema.safeParse(parsed);
+    if (!result.success) return null;
+    return result.data;
+  } catch {
+    return null;
+  }
+}
+const LooseRequestSchema = object({
+  model: string().optional(),
+  metadata: object({ user_id: string().optional() }).passthrough().optional()
+});
+const MAX_MEMORY_CACHE = 100;
+const memoryCache = /* @__PURE__ */ new Map();
+let headId = null;
+let tailId = null;
+const prevMap = /* @__PURE__ */ new Map();
+const nextMap = /* @__PURE__ */ new Map();
+function evictOldestIfNeeded() {
+  while (memoryCache.size >= MAX_MEMORY_CACHE && headId !== null) {
+    const oldest = headId;
+    const next = nextMap.get(oldest) ?? null;
+    memoryCache.delete(oldest);
+    prevMap.delete(oldest);
+    nextMap.delete(oldest);
+    if (next !== null) {
+      prevMap.set(next, null);
+      headId = next;
+    } else {
+      headId = null;
+      tailId = null;
+    }
+  }
+}
+function addToCache(log) {
+  evictOldestIfNeeded();
+  if (tailId !== null) {
+    nextMap.set(tailId, log.id);
+    prevMap.set(log.id, tailId);
+  } else {
+    headId = log.id;
+    prevMap.set(log.id, null);
+  }
+  nextMap.set(log.id, null);
+  tailId = log.id;
+  memoryCache.set(log.id, log);
+}
+async function addTestLogEntry(entry) {
+  const id = await getNextLogId();
+  const index = await loadIndex();
+  if (id > index.maxId) {
+    index.maxId = id;
+    await saveIndex(index);
+  }
+  let streamingChunksPath = null;
+  if (entry.streamingChunks !== void 0 && entry.streamingChunks.chunks.length > 0) {
+    streamingChunksPath = writeChunks(
+      id,
+      entry.streamingChunks.chunks,
+      entry.streamingChunks.truncated
+    );
+  }
+  const log = {
+    id,
+    ...entry,
+    streamingChunksPath
+  };
+  addToCache(log);
+  emitLogUpdate(log);
+  return log;
+}
+async function createLog(method, path2, requestBody, headers, clientInfo, rawHeaders, upstreamHeaders, apiFormat = "unknown") {
+  let model = null;
+  let sessionId = null;
+  if (requestBody !== null) {
+    try {
+      const json = JSON.parse(requestBody);
+      const loose = LooseRequestSchema.safeParse(json);
+      if (loose.success) {
+        model = loose.data.model ?? null;
+        sessionId = loose.data.metadata?.user_id ?? headers.get("x-session-affinity") ?? null;
+      }
+    } catch {
+    }
+  }
+  const userAgent = headers.get("user-agent");
+  const origin = headers.get("origin");
+  const id = await getNextLogId();
+  const log = {
+    id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method,
+    path: path2,
+    model,
+    sessionId,
+    rawRequestBody: requestBody,
+    responseStatus: null,
+    responseText: null,
+    inputTokens: null,
+    outputTokens: null,
+    cacheCreationInputTokens: null,
+    cacheReadInputTokens: null,
+    elapsedMs: null,
+    streaming: false,
+    userAgent,
+    origin,
+    rawHeaders,
+    headers: upstreamHeaders,
+    apiFormat,
+    isTest: false,
+    providerName: null,
+    clientPort: clientInfo?.port ?? null,
+    clientPid: clientInfo?.pid ?? null,
+    clientCwd: clientInfo?.cwd ?? null,
+    clientProjectFolder: clientInfo?.projectFolder ?? null,
+    streamingChunksPath: null
+  };
+  const logFile = getCurrentLogFile();
+  appendLogEntry(log);
+  await addToIndex(id, logFile, -1, -1);
+  addToCache(log);
+  emitLogUpdate(log);
+  return log;
+}
+async function getLogById(id) {
+  const cached = memoryCache.get(id);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const entry = await findInIndex(id);
+  if (entry === null) {
+    return null;
+  }
+  try {
+    const filePath = join(resolveLogDir(), entry.file);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    let lastMatch = null;
+    for (const line of lines) {
+      if (line.trim() === "") continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === "object" && parsed !== null) {
+          const desc = Object.getOwnPropertyDescriptor(parsed, "id");
+          if (desc !== void 0 && typeof desc.value === "number" && desc.value === id) {
+            const result = CapturedLogSchema.safeParse(parsed);
+            if (result.success) {
+              lastMatch = result.data;
+              if (result.data.responseStatus !== null) {
+                return result.data;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (lastMatch !== null) return lastMatch;
+  } catch (err) {
+    console.error("[store] Failed to read log from disk:", err);
+  }
+  return null;
+}
+function getFilteredLogs(sessionId, model) {
+  const cachedLogs = Array.from(memoryCache.values()).sort((a, b) => a.id - b.id);
+  return cachedLogs.filter((l) => {
+    if (sessionId !== void 0 && l.sessionId !== sessionId) return false;
+    if (model !== void 0 && l.model !== model) return false;
+    return true;
+  });
+}
+function getSessions() {
+  const set = /* @__PURE__ */ new Set();
+  for (const l of memoryCache.values()) {
+    if (l.sessionId !== null && l.sessionId !== "") set.add(l.sessionId);
+  }
+  return [...set];
+}
+function getModels() {
+  const set = /* @__PURE__ */ new Set();
+  for (const l of memoryCache.values()) {
+    if (l.model !== null && l.model !== "") set.add(l.model);
+  }
+  return [...set];
+}
+function clearAllLogs() {
+  const count = memoryCache.size;
+  memoryCache.clear();
+  headId = null;
+  tailId = null;
+  prevMap.clear();
+  nextMap.clear();
+  return { cleared: count };
+}
+const sseHandlers = /* @__PURE__ */ new Set();
+function onLogUpdate(handler) {
+  sseHandlers.add(handler);
+  return () => {
+    sseHandlers.delete(handler);
+  };
+}
+function emitLogUpdate(log) {
+  for (const handler of sseHandlers) {
+    try {
+      handler(log);
+    } catch {
+      sseHandlers.delete(handler);
+    }
+  }
+}
+const DEFAULT_UPSTREAM$1 = "https://api.anthropic.com";
+const DEFAULT_OPENAI_UPSTREAM$1 = "https://api.openai.com/v1";
+const PROXY_IDENTITY = process.env["PROXY_IDENTITY"] ?? "inspector9527@Tony";
+const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
+const PATH_CHAT_COMPLETIONS = "/chat/completions";
+const PATH_V1_MESSAGES = "/v1/messages";
+const HEADER_CONTENT_TYPE = "content-type";
+const HEADER_USER_AGENT = "user-agent";
+const HEADER_X_PROXY_IDENTITY = "x-proxy-identity";
+const HEADER_AUTHORIZATION = "authorization";
+const HEADER_X_API_KEY = "x-api-key";
+const HEADER_CONTENT_ENCODING = "content-encoding";
+const HEADER_CONTENT_LENGTH = "content-length";
+const HEADER_HOST = "host";
+const AUTH_HEADER_X_API_KEY = "x-api-key";
+const CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+const STATUS_FORBIDDEN = 403;
+const STATUS_BAD_GATEWAY = 502;
+const PRESERVE_HEADERS = /* @__PURE__ */ new Set([HEADER_CONTENT_TYPE]);
+class FormatRegistryImpl {
+  handlers = /* @__PURE__ */ new Map();
+  pathMap = /* @__PURE__ */ new Map();
+  register(handler) {
+    this.handlers.set(handler.format, handler);
+  }
+  registerPath(path2, format) {
+    this.pathMap.set(path2, format);
+  }
+  /** Get handler by format identifier */
+  get(format) {
+    return this.handlers.get(format);
+  }
+  /** Get handler matching a request path */
+  getByPath(path2) {
+    const messagesPath = path2.split("?")[0] ?? "";
+    if (messagesPath === PATH_V1_MESSAGES) return this.handlers.get("anthropic");
+    if (messagesPath === PATH_V1_CHAT_COMPLETIONS || messagesPath === PATH_CHAT_COMPLETIONS) {
+      return this.handlers.get("openai");
+    }
+    return void 0;
+  }
+  /** Detect format from request body content */
+  detectFormat(rawBody) {
+    if (rawBody === null) return "unknown";
+    for (const handler of this.handlers.values()) {
+      if (handler.detectFormat(rawBody)) return handler.format;
+    }
+    return "unknown";
+  }
+}
+const formatRegistry = new FormatRegistryImpl();
+function formatForPath(path2) {
+  return formatRegistry.getByPath(path2) ?? null;
+}
+formatRegistry.registerPath(PATH_V1_MESSAGES, "anthropic");
+formatRegistry.registerPath(PATH_V1_CHAT_COMPLETIONS, "openai");
+formatRegistry.registerPath(PATH_CHAT_COMPLETIONS, "openai");
+function parseInputJson(json) {
+  if (json === "") return {};
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { ...parsed };
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function finalizeBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "thinking": {
+      const out = { type: "thinking", thinking: block.thinking };
+      if (block.signature !== "") out.signature = block.signature;
+      return out;
+    }
+    case "tool_use":
+      return {
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: parseInputJson(block.inputJson)
+      };
+  }
+}
+function extractAnthropicStream(raw, log, fallbackModel, collectChunks) {
+  const blocks = /* @__PURE__ */ new Map();
+  let id = "";
+  let model = "";
+  let stopReason = null;
+  let stopSequence = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const MAX_CHUNKS = 1e3;
+  let chunkIndex = 0;
+  let streamStartMs = 0;
+  const chunks = [];
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    try {
+      const json = JSON.parse(line.slice(6));
+      const parsed = SseEventSchema.safeParse(json);
+      if (!parsed.success) continue;
+      const data = parsed.data;
+      if (chunkIndex === 0) streamStartMs = Date.now();
+      if (collectChunks === true && chunks.length < MAX_CHUNKS) {
+        chunks.push({
+          index: chunkIndex,
+          timestamp: Date.now() - streamStartMs,
+          type: data.type,
+          data: JsonValueSchema.parse(data)
+        });
+      }
+      chunkIndex++;
+      switch (data.type) {
+        case "message_start":
+          id = data.message.id;
+          model = data.message.model;
+          inputTokens = data.message.usage.input_tokens;
+          log.inputTokens = inputTokens;
+          log.cacheCreationInputTokens = data.message.usage.cache_creation_input_tokens ?? null;
+          log.cacheReadInputTokens = data.message.usage.cache_read_input_tokens ?? null;
+          if (log.model === null) log.model = model;
+          break;
+        case "content_block_start": {
+          const cb = data.content_block;
+          if (cb.type === "text") {
+            blocks.set(data.index, { type: "text", text: cb.text ?? "" });
+          } else if (cb.type === "thinking") {
+            blocks.set(data.index, {
+              type: "thinking",
+              thinking: cb.thinking ?? "",
+              signature: cb.signature ?? ""
+            });
+          } else {
+            blocks.set(data.index, {
+              type: "tool_use",
+              id: cb.id,
+              name: cb.name,
+              inputJson: ""
+            });
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const block = blocks.get(data.index);
+          if (block === void 0) break;
+          const delta = data.delta;
+          if (delta.type === "text_delta" && block.type === "text") {
+            block.text += delta.text;
+          } else if (delta.type === "thinking_delta" && block.type === "thinking") {
+            block.thinking += delta.thinking;
+          } else if (delta.type === "signature_delta" && block.type === "thinking") {
+            block.signature += delta.signature;
+          } else if (delta.type === "input_json_delta" && block.type === "tool_use") {
+            block.inputJson += delta.partial_json;
+          }
+          break;
+        }
+        case "message_delta":
+          stopReason = data.delta.stop_reason;
+          stopSequence = data.delta.stop_sequence ?? null;
+          outputTokens = data.usage.output_tokens;
+          log.outputTokens = outputTokens;
+          break;
+        case "content_block_stop":
+        case "message_stop":
+        case "ping":
+          break;
+      }
+    } catch {
+    }
+  }
+  if (collectChunks === true) {
+    log.streamingChunks = {
+      chunks,
+      truncated: chunkIndex > MAX_CHUNKS
+    };
+  }
+  const orderedContent = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, block]) => finalizeBlock(block));
+  return JSON.stringify({
+    id,
+    type: "message",
+    model: model !== "" ? model : fallbackModel ?? "",
+    role: "assistant",
+    content: orderedContent,
+    stop_reason: stopReason,
+    stop_sequence: stopSequence,
+    usage: { input_tokens: inputTokens, output_tokens: outputTokens }
+  });
+}
+const AnthropicFormatHandler = {
+  format: "anthropic",
+  parseRequest(rawBody, headers) {
+    try {
+      const json = JSON.parse(rawBody);
+      const result = AnthropicRequestSchema.safeParse(json);
+      if (result.success) {
+        return {
+          model: result.data.model,
+          sessionId: result.data.metadata?.user_id ?? headers?.get("x-session-affinity") ?? null
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+  extractTokens(responseBody) {
+    try {
+      const json = JSON.parse(responseBody);
+      const result = AnthropicResponseSchema$1.safeParse(json);
+      if (result.success) {
+        return {
+          inputTokens: result.data.usage.input_tokens,
+          outputTokens: result.data.usage.output_tokens,
+          cacheCreationInputTokens: result.data.usage.cache_creation_input_tokens ?? null,
+          cacheReadInputTokens: result.data.usage.cache_read_input_tokens ?? null
+        };
+      }
+    } catch {
+    }
+    return {
+      inputTokens: null,
+      outputTokens: null,
+      cacheCreationInputTokens: null,
+      cacheReadInputTokens: null
+    };
+  },
+  extractStream(raw, log, fallbackModel, collectChunks) {
+    return extractAnthropicStream(raw, log, fallbackModel, collectChunks);
+  },
+  detectFormat(rawBody) {
+    if (rawBody === null) return false;
+    try {
+      const json = JSON.parse(rawBody);
+      if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+        const keys = Object.keys(json);
+        if (keys.includes("model") && keys.includes("messages")) {
+          if (keys.includes("system") || keys.includes("tools")) {
+            return true;
+          }
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+};
+formatRegistry.register(AnthropicFormatHandler);
+class ProviderRegistryImpl {
+  providers = [];
+  /**
+   * Register a provider with the registry.
+   * @param provider - Provider implementation to register
+   */
+  register(provider) {
+    this.providers.push(provider);
+  }
+  /**
+   * Find the first provider that matches the given model.
+   * @param model - Model name to match
+   * @returns Matching provider or null if none found
+   */
+  findProvider(model) {
+    let fallback = null;
+    for (const provider of this.providers) {
+      if (provider.matches(model)) {
+        if (provider.name !== "anthropic") {
+          return provider;
+        }
+        fallback = provider;
+      }
+    }
+    return fallback;
+  }
+  /**
+   * Get all registered providers.
+   * @returns Array of all registered providers
+   */
+  getAll() {
+    return [...this.providers];
+  }
+}
+const registry = new ProviderRegistryImpl();
+const DEFAULT_UPSTREAM = "https://api.anthropic.com";
+const DEFAULT_ROUTES = {
+  MiniMax: "https://api.minimaxi.com/anthropic"
+};
+const anthropicProvider = {
+  name: "anthropic",
+  matches(model) {
+    const modelLower = model.toLowerCase();
+    if (modelLower.startsWith("openai-")) {
+      return false;
+    }
+    if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
+      return true;
+    }
+    for (const prefix of Object.keys(DEFAULT_ROUTES)) {
+      if (modelLower.startsWith(prefix.toLowerCase())) {
+        return true;
+      }
+    }
+    return true;
+  },
+  getUpstreamBase(_isChatCompletions, providerConfig) {
+    if (providerConfig?.baseUrl !== void 0) {
+      return providerConfig.baseUrl;
+    }
+    return DEFAULT_UPSTREAM;
+  },
+  extractStream(raw, log, fallbackModel, collectChunks) {
+    return extractAnthropicStream(raw, log, fallbackModel, collectChunks);
+  }
+};
+registry.register(anthropicProvider);
+function extractOpenAIStream(raw, log, fallbackModel, collectChunks = true) {
+  let id = "";
+  let model = "";
+  let completionContent = "";
+  let reasoningContent = "";
+  let finishReason = null;
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let usageCaptured = false;
+  let started = false;
+  const toolCalls = [];
+  const MAX_CHUNKS = 1e3;
+  let chunkIndex = 0;
+  let streamStartMs = 0;
+  const chunks = [];
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    const dataStr = line.slice(6).trim();
+    if (dataStr === "[DONE]") break;
+    try {
+      const parsed = JSON.parse(dataStr);
+      const chunkResult = OpenAISSERawChunkSchema.safeParse(parsed);
+      if (!chunkResult.success) continue;
+      const chunk = chunkResult.data;
+      if (chunkIndex === 0) streamStartMs = Date.now();
+      if (collectChunks === true && chunks.length < MAX_CHUNKS) {
+        const jsonResult = JsonValueSchema.safeParse(chunk);
+        if (jsonResult.success) {
+          chunks.push({
+            index: chunkIndex,
+            timestamp: Date.now() - streamStartMs,
+            type: "chat.completion.chunk",
+            data: jsonResult.data
+          });
+        }
+      }
+      chunkIndex++;
+      if (!started) {
+        id = chunk.id;
+        model = chunk.model;
+        started = true;
+      }
+      if (!usageCaptured && chunk.usage !== void 0 && chunk.usage !== null) {
+        promptTokens = chunk.usage.prompt_tokens;
+        completionTokens = chunk.usage.completion_tokens;
+        log.inputTokens = promptTokens;
+        usageCaptured = true;
+      }
+      for (const choice of chunk.choices) {
+        const delta = choice.delta;
+        if (delta.content !== void 0 && delta.content !== null) {
+          completionContent += delta.content;
+        }
+        if (delta.reasoning_content !== void 0 && delta.reasoning_content !== null) {
+          reasoningContent += delta.reasoning_content;
+        }
+        if (choice.finish_reason !== void 0 && choice.finish_reason !== null) {
+          finishReason = choice.finish_reason;
+        }
+        if (delta.tool_calls !== void 0 && delta.tool_calls !== null) {
+          for (const tc of delta.tool_calls) {
+            let existing = toolCalls.find((t) => t.index === tc.index);
+            if (!existing) {
+              existing = {
+                index: tc.index,
+                type: "function",
+                function: { name: "", arguments: "" }
+              };
+              toolCalls.push(existing);
+            }
+            if (tc.id !== void 0) existing.id = tc.id;
+            if (tc.function?.name !== void 0) existing.function.name += tc.function.name;
+            if (tc.function?.arguments !== void 0)
+              existing.function.arguments += tc.function.arguments;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (collectChunks === true) {
+    log.streamingChunks = {
+      chunks,
+      truncated: chunkIndex > MAX_CHUNKS
+    };
+  }
+  if (!usageCaptured) {
+    completionTokens = Math.ceil(completionContent.length / 4);
+  }
+  log.outputTokens = completionTokens;
+  const message = {
+    role: "assistant",
+    content: completionContent
+  };
+  if (reasoningContent) message.reasoning_content = reasoningContent;
+  if (toolCalls.length > 0) message.tool_calls = toolCalls;
+  return JSON.stringify({
+    id,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: model !== "" ? model : fallbackModel ?? "",
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: finishReason
+      }
+    ],
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: promptTokens + completionTokens
+    }
+  });
+}
+const OpenAIFormatHandler = {
+  format: "openai",
+  parseRequest(rawBody, headers) {
+    try {
+      const json = JSON.parse(rawBody);
+      const result = OpenAIRequestSchema.safeParse(json);
+      if (result.success) {
+        return {
+          model: result.data.model,
+          sessionId: headers?.get("x-session-affinity") ?? null
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+  extractTokens(responseBody) {
+    const parsed = parseOpenAIResponse(responseBody);
+    if (parsed) {
+      return {
+        inputTokens: parsed.usage.prompt_tokens,
+        outputTokens: parsed.usage.completion_tokens,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: null
+      };
+    }
+    return {
+      inputTokens: null,
+      outputTokens: null,
+      cacheCreationInputTokens: null,
+      cacheReadInputTokens: null
+    };
+  },
+  extractStream(raw, log, fallbackModel, collectChunks) {
+    return extractOpenAIStream(raw, log, fallbackModel, collectChunks);
+  },
+  detectFormat(rawBody) {
+    if (rawBody === null) return false;
+    try {
+      const json = JSON.parse(rawBody);
+      if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+        const keys = Object.keys(json);
+        if (keys.includes("model") && keys.includes("messages")) {
+          if (!keys.includes("system") && !keys.includes("tools")) {
+            return true;
+          }
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+};
+formatRegistry.register(OpenAIFormatHandler);
+const DEFAULT_OPENAI_UPSTREAM = "https://api.openai.com/v1";
+const openaiProvider = {
+  name: "openai",
+  matches(model) {
+    const modelLower = model.toLowerCase();
+    if (modelLower.startsWith("openai-")) {
+      return true;
+    }
+    if (modelLower.includes("gpt-") || modelLower.includes("o1") || modelLower.includes("o2") || modelLower.includes("o3")) {
+      return true;
+    }
+    return false;
+  },
+  getUpstreamBase(_isChatCompletions, providerConfig) {
+    if (providerConfig?.baseUrl !== void 0) {
+      return providerConfig.baseUrl;
+    }
+    return DEFAULT_OPENAI_UPSTREAM;
+  },
+  extractStream(raw, log, fallbackModel, collectChunks) {
+    return extractOpenAIStream(raw, log, fallbackModel, collectChunks);
+  }
+};
+registry.register(openaiProvider);
+const DEFAULT_ALIBABA_UPSTREAM = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+const alibabaProvider = {
+  name: "alibaba",
+  matches(model) {
+    const m = model.toLowerCase().replace(/\s+/g, "-");
+    if (m.startsWith("glm-5")) {
+      return true;
+    }
+    if (m.startsWith("qwen")) {
+      return true;
+    }
+    return false;
+  },
+  getUpstreamBase(_isChatCompletions, _providerConfig) {
+    return DEFAULT_ALIBABA_UPSTREAM;
+  },
+  extractStream(raw, log, fallbackModel) {
+    return extractOpenAIStream(raw, log, fallbackModel);
+  }
+};
+registry.register(alibabaProvider);
+const ProviderConfigSchema = object({
+  id: string(),
+  name: string(),
+  apiKey: string(),
+  model: string().optional(),
+  /** API format: "anthropic" or "openai" */
+  format: _enum(["anthropic", "openai"]).optional(),
+  /** Base URL for the provider (deprecated - use anthropicBaseUrl/openaiBaseUrl instead) */
+  baseUrl: string().optional(),
+  /** Anthropic API base URL */
+  anthropicBaseUrl: string().optional(),
+  /** OpenAI API base URL */
+  openaiBaseUrl: string().optional(),
+  /** Auth header to use: "bearer" (default) or "x-api-key" */
+  authHeader: _enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  createdAt: string(),
+  updatedAt: string()
+});
+object({
+  providers: array(ProviderConfigSchema)
+});
+const store = new Conf({
+  projectName: "llm-inspector",
+  defaults: {
+    providers: []
+  }
+});
+function migrateProviders() {
+  const providers = store.get("providers", []);
+  let migrated = false;
+  const updated = providers.map((p) => {
+    function getOldUrl(obj, key) {
+      if (obj !== null && typeof obj === "object") {
+        const desc = Object.getOwnPropertyDescriptor(obj, key);
+        if (desc !== void 0 && typeof desc.value === "string") {
+          return desc.value;
+        }
+      }
+      return "";
+    }
+    const oldAnthropicBaseUrl = getOldUrl(p, "anthropicBaseUrl");
+    const oldOpenaiBaseUrl = getOldUrl(p, "openaiBaseUrl");
+    if (p.format !== void 0 && oldAnthropicBaseUrl === "" && oldOpenaiBaseUrl === "") {
+      return p;
+    }
+    const newAnthropicUrl = oldAnthropicBaseUrl !== "" ? oldAnthropicBaseUrl : p.anthropicBaseUrl ?? "";
+    const newOpenaiUrl = oldOpenaiBaseUrl !== "" ? oldOpenaiBaseUrl : p.openaiBaseUrl ?? "";
+    let format;
+    let baseUrl;
+    if (newAnthropicUrl !== "" && newOpenaiUrl !== "") {
+      format = p.format ?? "anthropic";
+      baseUrl = p.baseUrl !== void 0 && p.baseUrl !== "" ? p.baseUrl : newAnthropicUrl;
+    } else if (newOpenaiUrl !== "") {
+      format = "openai";
+      baseUrl = newOpenaiUrl;
+    } else if (newAnthropicUrl !== "") {
+      format = "anthropic";
+      baseUrl = newAnthropicUrl;
+    }
+    migrated = true;
+    return {
+      ...p,
+      format,
+      baseUrl,
+      anthropicBaseUrl: newAnthropicUrl,
+      openaiBaseUrl: newOpenaiUrl
+    };
+  });
+  if (migrated) {
+    store.set("providers", updated);
+  }
+}
+migrateProviders();
+function getProviders() {
+  return store.get("providers", []);
+}
+function getProvider(id) {
+  const providers = getProviders();
+  return providers.find((p) => p.id === id);
+}
+function normalizeApiKey(apiKey) {
+  return apiKey.replace(/^Bearer\s+/i, "").trim();
+}
+function addProvider(name, apiKey, format, baseUrl, model, authHeader) {
+  const providers = getProviders();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newProvider = {
+    id: randomUUID(),
+    name,
+    apiKey: normalizeApiKey(apiKey),
+    format,
+    baseUrl,
+    model,
+    authHeader: authHeader ?? "bearer",
+    createdAt: now,
+    updatedAt: now
+  };
+  providers.push(newProvider);
+  store.set("providers", providers);
+  return newProvider;
+}
+function updateProvider(id, updates) {
+  const providers = getProviders();
+  const existing = providers.find((p) => p.id === id);
+  if (!existing) return null;
+  const updated = {
+    id: existing.id,
+    name: updates.name ?? existing.name,
+    apiKey: updates.apiKey !== void 0 ? normalizeApiKey(updates.apiKey) : existing.apiKey,
+    model: updates.model !== void 0 ? updates.model : existing.model,
+    format: updates.format ?? existing.format,
+    baseUrl: updates.baseUrl !== void 0 ? updates.baseUrl : existing.baseUrl,
+    authHeader: updates.authHeader ?? existing.authHeader,
+    createdAt: existing.createdAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const index = providers.findIndex((p) => p.id === id);
+  providers[index] = updated;
+  store.set("providers", providers);
+  return updated;
+}
+function deleteProvider(id) {
+  const providers = getProviders();
+  const filtered = providers.filter((p) => p.id !== id);
+  if (filtered.length === providers.length) return false;
+  store.set("providers", filtered);
+  return true;
+}
+function getModelUsageName(model, providerName) {
+  if (providerName !== void 0 && providerName !== "" && providerName.toLowerCase().includes("minimax")) {
+    return model.replace(/ /g, "-");
+  }
+  return model;
+}
+function normalizeModelName(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function findProviderByModel(model) {
+  const providers = getProviders();
+  const modelLower = model.toLowerCase();
+  const modelNormalized = normalizeModelName(model);
+  for (const provider of providers) {
+    const providerPrefix = (provider.name + "-").toLowerCase();
+    if (modelLower.startsWith(providerPrefix)) {
+      return provider;
+    }
+    if (provider.model !== void 0 && provider.model !== "" && modelNormalized === normalizeModelName(provider.model)) {
+      return provider;
+    }
+  }
+  return null;
+}
+const execAsync = promisify(exec);
+const cache = /* @__PURE__ */ new Map();
+const CACHE_TTL_MS = 5 * 60 * 1e3;
+function getFromCache(port) {
+  const entry = cache.get(port);
+  if (entry && Date.now() < entry.expiresAt) {
+    return { port: entry.port, pid: entry.pid, cwd: entry.cwd, projectFolder: entry.projectFolder };
+  }
+  if (entry) cache.delete(port);
+  return null;
+}
+function setCache(port, info) {
+  cache.set(port, { ...info, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+function extractRemotePort(request) {
+  const socket = request.socket;
+  const remotePort = socket?.remotePort;
+  if (remotePort !== void 0 && remotePort !== null) return remotePort;
+  return null;
+}
+async function lookupPidByPort(port) {
+  try {
+    const { stdout } = await execAsync(`netstat -aon | findstr :${port} | findstr ESTABLISHED`, {
+      windowsHide: true
+    });
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      const lastPart = parts[parts.length - 1];
+      if (lastPart !== void 0) {
+        const pid = parseInt(lastPart, 10);
+        if (!isNaN(pid) && pid > 0) return pid;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function lookupProcessInfo(pid) {
+  try {
+    const { stdout } = await execAsync(
+      `wmic process where processid=${pid} get commandline /value`,
+      { windowsHide: true }
+    );
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      if (line.includes("=")) {
+        const commandLine = (line.split("=")[1] ?? "").trim();
+        if (commandLine) {
+          const exeMatch = commandLine.match(/^"([^"]+)"/) || commandLine.match(/^([^\s]+)/);
+          if (exeMatch && exeMatch[1] !== void 0) {
+            const exePath = exeMatch[1];
+            const exeDir = exePath.substring(0, exePath.lastIndexOf("\\"));
+            return {
+              cwd: exeDir,
+              projectFolder: exeDir.split("\\").pop() ?? null
+            };
+          }
+        }
+      }
+    }
+    return { cwd: null, projectFolder: null };
+  } catch {
+    return { cwd: null, projectFolder: null };
+  }
+}
+async function getClientInfo(request) {
+  const port = extractRemotePort(request);
+  if (port === null) {
+    return { port: null, pid: null, cwd: null, projectFolder: null };
+  }
+  const cached = getFromCache(port);
+  if (cached) return cached;
+  const pid = await lookupPidByPort(port);
+  if (pid === null) {
+    const info2 = { port, pid: null, cwd: null, projectFolder: null };
+    setCache(port, info2);
+    return info2;
+  }
+  const { cwd, projectFolder } = await lookupProcessInfo(pid);
+  const info = { port, pid, cwd, projectFolder };
+  setCache(port, info);
+  return info;
+}
+function buildProxyHeaders(originalHeaders) {
+  const rawHeaders = {};
+  const headers = new Headers();
+  originalHeaders.forEach((value, key) => {
+    rawHeaders[key.toLowerCase()] = value;
+  });
+  headers.set(HEADER_USER_AGENT, PROXY_IDENTITY);
+  headers.set(HEADER_X_PROXY_IDENTITY, PROXY_IDENTITY);
+  for (const name of PRESERVE_HEADERS) {
+    const value = originalHeaders.get(name);
+    if (value !== null) {
+      headers.set(name, value);
+    }
+  }
+  return { headers, rawHeaders };
+}
+function getHostFromUrl$1(urlStr) {
+  try {
+    const url = new URL(urlStr);
+    return url.host;
+  } catch {
+    return "api.anthropic.com";
+  }
+}
+function buildFileLogEntry(log, upstreamUrl) {
+  return {
+    timestamp: log.timestamp,
+    id: log.id,
+    method: log.method,
+    path: log.path,
+    model: log.model,
+    sessionId: log.sessionId,
+    rawRequestBody: log.rawRequestBody,
+    responseStatus: log.responseStatus,
+    responseText: log.responseText,
+    inputTokens: log.inputTokens,
+    outputTokens: log.outputTokens,
+    elapsedMs: log.elapsedMs,
+    streaming: log.streaming,
+    userAgent: log.userAgent,
+    origin: log.origin,
+    upstreamUrl,
+    clientPort: log.clientPort,
+    clientPid: log.clientPid,
+    clientCwd: log.clientCwd,
+    clientProjectFolder: log.clientProjectFolder,
+    streamingChunks: log.streamingChunks,
+    streamingChunksPath: log.streamingChunksPath
+  };
+}
+function parseRequestPath(req, url) {
+  const apiPath = url.pathname.replace(/^\/proxy/, "") + url.search;
+  const messagesPath = apiPath.split("?")[0] ?? "";
+  const isChatCompletionsV1 = messagesPath === PATH_V1_CHAT_COMPLETIONS;
+  const isChatCompletions = messagesPath === PATH_CHAT_COMPLETIONS || isChatCompletionsV1;
+  const isMessages = req.method === "POST" && (messagesPath === PATH_V1_MESSAGES || messagesPath === PATH_V1_CHAT_COMPLETIONS || messagesPath === PATH_CHAT_COMPLETIONS);
+  const normalizedPath = isChatCompletions && !apiPath.startsWith("/v1/") ? "/v1" + apiPath : apiPath;
+  return {
+    apiPath,
+    messagesPath,
+    isChatCompletionsV1,
+    isChatCompletions,
+    isMessages,
+    normalizedPath
+  };
+}
+function buildUpstreamUrl$1(upstreamBase, normalizedPath) {
+  return upstreamBase + normalizedPath;
+}
+function selectUpstreamBase$1(isChatCompletions, matchedProviderConfig) {
+  let upstreamBase;
+  if (matchedProviderConfig) {
+    if (isChatCompletions && matchedProviderConfig.openaiBaseUrl !== void 0 && matchedProviderConfig.openaiBaseUrl !== "") {
+      upstreamBase = matchedProviderConfig.openaiBaseUrl;
+    } else if (!isChatCompletions && matchedProviderConfig.anthropicBaseUrl !== void 0 && matchedProviderConfig.anthropicBaseUrl !== "") {
+      upstreamBase = matchedProviderConfig.anthropicBaseUrl;
+    } else if (matchedProviderConfig.baseUrl !== void 0 && matchedProviderConfig.baseUrl !== "") {
+      upstreamBase = matchedProviderConfig.baseUrl;
+    } else {
+      upstreamBase = matchedProviderConfig.format === "openai" ? DEFAULT_OPENAI_UPSTREAM$1 : DEFAULT_UPSTREAM$1;
+    }
+  } else {
+    upstreamBase = isChatCompletions ? DEFAULT_OPENAI_UPSTREAM$1 : DEFAULT_UPSTREAM$1;
+  }
+  return upstreamBase;
+}
+function injectAuthHeaders$1(upstreamHeaders, matchedProviderConfig) {
+  if (!matchedProviderConfig) return;
+  const apiKey = matchedProviderConfig.apiKey.replace(/^Bearer\s+/i, "").trim();
+  if (matchedProviderConfig.authHeader === AUTH_HEADER_X_API_KEY) {
+    upstreamHeaders.set(HEADER_X_API_KEY, apiKey);
+    upstreamHeaders.delete(HEADER_AUTHORIZATION);
+  } else {
+    upstreamHeaders.set(HEADER_AUTHORIZATION, `Bearer ${apiKey}`);
+  }
+}
+function handleNonStreamingResponse(upstreamRes, responseBody, startTime, formatHandler, upstreamUrl, log) {
+  const elapsedMs = Date.now() - startTime;
+  const tokens = formatHandler.extractTokens(responseBody);
+  log.elapsedMs = elapsedMs;
+  log.responseStatus = upstreamRes.status;
+  log.responseText = responseBody;
+  log.inputTokens = tokens.inputTokens;
+  log.outputTokens = tokens.outputTokens;
+  log.cacheCreationInputTokens = tokens.cacheCreationInputTokens;
+  log.cacheReadInputTokens = tokens.cacheReadInputTokens;
+  appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: null });
+  const responseHeaders = new Headers(upstreamRes.headers);
+  responseHeaders.delete(HEADER_CONTENT_ENCODING);
+  responseHeaders.delete(HEADER_CONTENT_LENGTH);
+  return new Response(responseBody, {
+    status: upstreamRes.status,
+    headers: responseHeaders
+  });
+}
+function handleStreamingResponse(upstreamRes, req, startTime, formatHandler, upstreamUrl, log) {
+  log.streaming = true;
+  log.responseStatus = upstreamRes.status;
+  const chunks = [];
+  const decoder = new TextDecoder();
+  const transform = new TransformStream({
+    transform(chunk, controller) {
+      controller.enqueue(chunk);
+      chunks.push(decoder.decode(chunk, { stream: true }));
+    },
+    flush() {
+      const full = chunks.join("");
+      log.elapsedMs = Date.now() - startTime;
+      log.responseText = formatHandler.extractStream(full, log, log.model ?? void 0, true);
+      if (log.streamingChunks && log.streamingChunks.chunks.length > 0) {
+        const chunkPath = writeChunks(
+          log.id,
+          log.streamingChunks.chunks,
+          log.streamingChunks.truncated
+        );
+        log.streamingChunksPath = chunkPath;
+      }
+      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: null });
+      emitLogUpdate(log);
+    }
+  });
+  if (upstreamRes.body === null) {
+    return new Response("No response body", { status: STATUS_BAD_GATEWAY });
+  }
+  const loggedStream = upstreamRes.body.pipeThrough(transform);
+  req.signal?.addEventListener("abort", () => {
+    if (log.responseText === null && chunks.length > 0) {
+      const full = chunks.join("");
+      log.elapsedMs = Date.now() - startTime;
+      log.responseText = formatHandler.extractStream(full, log, log.model ?? void 0, true);
+      if (log.streamingChunks && log.streamingChunks.chunks.length > 0) {
+        const chunkPath = writeChunks(
+          log.id,
+          log.streamingChunks.chunks,
+          log.streamingChunks.truncated
+        );
+        log.streamingChunksPath = chunkPath;
+      }
+      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
+      emitLogUpdate(log);
+    }
+  });
+  const responseHeaders = new Headers(upstreamRes.headers);
+  responseHeaders.delete(HEADER_CONTENT_ENCODING);
+  responseHeaders.delete(HEADER_CONTENT_LENGTH);
+  return new Response(loggedStream, {
+    status: upstreamRes.status,
+    headers: responseHeaders
+  });
+}
+async function handleProxy(req) {
+  const url = new URL(req.url);
+  const parsed = parseRequestPath(req, url);
+  let requestBody = null;
+  if (req.body && req.method !== "GET" && req.method !== "HEAD") {
+    requestBody = await req.text();
+  }
+  const model = requestBody !== null ? extractModelFromBody(requestBody) : null;
+  const matchedProviderConfig = findProviderByModelFromConfig(requestBody);
+  const upstreamBase = selectUpstreamBase$1(parsed.isChatCompletions, matchedProviderConfig);
+  const upstreamUrl = buildUpstreamUrl$1(upstreamBase, parsed.normalizedPath);
+  const upstreamHost = getHostFromUrl$1(upstreamBase);
+  const startTime = Date.now();
+  const { headers: upstreamHeaders, rawHeaders } = buildProxyHeaders(req.headers);
+  upstreamHeaders.set(HEADER_HOST, upstreamHost);
+  injectAuthHeaders$1(upstreamHeaders, matchedProviderConfig);
+  const provider = model !== null ? registry.findProvider(model) : null;
+  if (model === null || provider === null) {
+    return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
+  }
+  let formatHandler;
+  if (matchedProviderConfig?.format) {
+    formatHandler = formatRegistry.get(matchedProviderConfig.format) ?? null;
+  } else {
+    formatHandler = formatForPath(parsed.apiPath);
+  }
+  if (formatHandler === null) {
+    return new Response("Forbidden: unsupported format", { status: STATUS_FORBIDDEN });
+  }
+  const clientInfo = await getClientInfo(req);
+  const upstreamHeadersObj = {};
+  upstreamHeaders.forEach((value, key) => {
+    upstreamHeadersObj[key.toLowerCase()] = value;
+  });
+  const log = await createLog(
+    req.method,
+    parsed.apiPath,
+    requestBody,
+    req.headers,
+    clientInfo,
+    rawHeaders,
+    upstreamHeadersObj,
+    formatHandler.format
+  );
+  let upstreamRes;
+  try {
+    upstreamRes = await fetch(upstreamUrl, {
+      method: req.method,
+      headers: upstreamHeaders,
+      body: requestBody
+    });
+  } catch (err) {
+    log.elapsedMs = Date.now() - startTime;
+    log.responseStatus = STATUS_BAD_GATEWAY;
+    log.responseText = String(err);
+    appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: String(err) });
+    return new Response(`Proxy error: ${err}`, { status: STATUS_BAD_GATEWAY });
+  }
+  const isStream = upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes(CONTENT_TYPE_EVENT_STREAM) ?? false;
+  if (!isStream) {
+    const responseBody = await upstreamRes.text();
+    return handleNonStreamingResponse(
+      upstreamRes,
+      responseBody,
+      startTime,
+      formatHandler,
+      upstreamUrl,
+      log
+    );
+  }
+  return handleStreamingResponse(upstreamRes, req, startTime, formatHandler, upstreamUrl, log);
+}
+function findProviderByModelFromConfig(requestBody) {
+  if (requestBody === null) return null;
+  const model = extractModelFromBody(requestBody);
+  if (model === null) return null;
+  return findProviderByModel(model);
+}
+const Route$c = createFileRoute("/proxy/$")({
+  server: {
+    handlers: {
+      GET: ({ request }) => handleProxy(request),
+      POST: ({ request }) => handleProxy(request),
+      PUT: ({ request }) => handleProxy(request),
+      DELETE: ({ request }) => handleProxy(request),
+      PATCH: ({ request }) => handleProxy(request),
+      OPTIONS: ({ request }) => handleProxy(request)
+    }
+  }
+});
+const Route$b = createFileRoute("/api/sessions")({
+  server: {
+    handlers: {
+      GET: () => Response.json(getSessions())
+    }
+  }
+});
+const ProviderInputSchema = object({
+  name: string().min(1, "Name is required"),
+  apiKey: string().min(1, "API key is required"),
+  format: _enum(["anthropic", "openai"]),
+  baseUrl: string().min(1, "Base URL is required"),
+  model: string().min(1, "Model is required"),
+  authHeader: _enum(["bearer", "x-api-key"]).optional().default("bearer")
+});
+const Route$a = createFileRoute("/api/providers")({
+  server: {
+    handlers: {
+      GET: () => {
+        return Response.json(getProviders());
+      },
+      POST: async ({ request }) => {
+        const parsed = ProviderInputSchema.safeParse(await request.json());
+        if (!parsed.success) {
+          return Response.json({ error: parsed.error.message }, { status: 400 });
+        }
+        const newProvider = addProvider(
+          parsed.data.name,
+          parsed.data.apiKey,
+          parsed.data.format,
+          parsed.data.baseUrl,
+          parsed.data.model,
+          parsed.data.authHeader
+        );
+        return Response.json(newProvider, { status: 201 });
+      }
+    }
+  }
+});
+const Route$9 = createFileRoute("/api/models")({
+  server: {
+    handlers: {
+      GET: () => Response.json(getModels())
+    }
+  }
+});
+const Route$8 = createFileRoute("/api/logs")({
+  server: {
+    handlers: {
+      GET: ({ request }) => {
+        const url = new URL(request.url);
+        const sessionId = url.searchParams.get("sessionId") ?? void 0;
+        const model = url.searchParams.get("model") ?? void 0;
+        const offset = Number(url.searchParams.get("offset") ?? 0);
+        const limit = Number(url.searchParams.get("limit") ?? 50);
+        const allLogs = getFilteredLogs(sessionId, model);
+        const paginatedLogs = allLogs.slice(offset, offset + limit);
+        return Response.json({
+          logs: paginatedLogs,
+          total: allLogs.length,
+          offset,
+          limit
+        });
+      },
+      DELETE: () => {
+        const result = clearAllLogs();
+        return Response.json({ success: true, cleared: result.cleared });
+      }
+    }
+  }
+});
+const Route$7 = createFileRoute("/api/health")({
+  server: {
+    handlers: {
+      GET: () => {
+        return Response.json({ status: "ok" });
+      }
+    }
+  }
+});
+const ProviderUpdateSchema = object({
+  name: string().min(1, "Name is required").optional(),
+  apiKey: string().min(1, "API key is required").optional(),
+  format: _enum(["anthropic", "openai"]).optional(),
+  baseUrl: string().min(1, "Base URL is required").optional(),
+  model: string().min(1, "Model is required").optional(),
+  authHeader: _enum(["bearer", "x-api-key"]).optional()
+});
+const Route$6 = createFileRoute("/api/providers/$providerId")({
+  server: {
+    handlers: {
+      GET: ({ params }) => {
+        const providers = getProviders();
+        const provider = providers.find((p) => p.id === params.providerId);
+        if (!provider) {
+          return Response.json({ error: "Provider not found" }, { status: 404 });
+        }
+        return Response.json(provider);
+      },
+      PUT: async ({ params, request }) => {
+        const parsed = ProviderUpdateSchema.safeParse(await request.json());
+        if (!parsed.success) {
+          return Response.json({ error: parsed.error.message }, { status: 400 });
+        }
+        const updated = updateProvider(params.providerId, parsed.data);
+        if (!updated) {
+          return Response.json({ error: "Provider not found" }, { status: 404 });
+        }
+        return Response.json(updated);
+      },
+      DELETE: ({ params }) => {
+        const deleted = deleteProvider(params.providerId);
+        if (!deleted) {
+          return Response.json({ error: "Provider not found" }, { status: 404 });
+        }
+        return Response.json({ success: true });
+      }
+    }
+  }
+});
+const Route$5 = createFileRoute("/api/logs/stream")({
+  server: {
+    handlers: {
+      GET: ({ request }) => {
+        const url = new URL(request.url);
+        const sessionId = url.searchParams.get("sessionId") ?? void 0;
+        const model = url.searchParams.get("model") ?? void 0;
+        let controllerRef = null;
+        const heartbeat = setInterval(() => {
+          if (controllerRef) {
+            try {
+              controllerRef.enqueue(new TextEncoder().encode(": heartbeat\n\n"));
+            } catch {
+            }
+          }
+        }, 3e4);
+        const unsubscribe = onLogUpdate((log) => {
+          if (!controllerRef) return;
+          if (sessionId !== void 0 && log.sessionId !== sessionId) return;
+          if (model !== void 0 && log.model !== model) return;
+          try {
+            const data = `data: ${JSON.stringify({ type: "update", log })}
+
+`;
+            controllerRef.enqueue(new TextEncoder().encode(data));
+          } catch {
+          }
+        });
+        const stream = new ReadableStream({
+          start(controller) {
+            controllerRef = controller;
+            const logs = getFilteredLogs(sessionId, model);
+            const initData = `data: ${JSON.stringify({ type: "init", logs })}
+
+`;
+            controller.enqueue(new TextEncoder().encode(initData));
+          },
+          cancel() {
+            clearInterval(heartbeat);
+            unsubscribe();
+            controllerRef = null;
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+      }
+    }
+  }
+});
+const Route$4 = createFileRoute("/api/logs/$id")({
+  server: {
+    handlers: {
+      GET: async ({ params }) => {
+        const id = Number(params.id);
+        if (isNaN(id)) {
+          return Response.json({ error: "Invalid ID" }, { status: 400 });
+        }
+        const log = await getLogById(id);
+        if (log === null) {
+          return Response.json({ error: "Log not found" }, { status: 404 });
+        }
+        return Response.json(log);
+      }
+    }
+  }
+});
+const Route$3 = createFileRoute("/api/config/paths")({
+  server: {
+    handlers: {
+      GET: () => {
+        return Response.json({
+          providerConfig: store.path
+        });
+      }
+    }
+  }
+});
+const AnthropicResponseSchema = object({
+  id: string().optional(),
+  type: string().optional(),
+  model: string().optional(),
+  usage: object({
+    input_tokens: number().optional(),
+    output_tokens: number().optional()
+  }).optional(),
+  content: array(
+    discriminatedUnion("type", [
+      object({ type: literal("text"), text: string() }),
+      object({ type: literal("thinking"), thinking: string() })
+    ])
+  )
+});
+const OpenAIResponseSchema = object({
+  id: string().optional(),
+  model: string().optional(),
+  usage: object({
+    prompt_tokens: number().optional(),
+    completion_tokens: number().optional()
+  }).optional(),
+  choices: array(
+    object({
+      message: object({
+        role: string(),
+        content: string().nullable()
+      }),
+      finish_reason: string().nullable()
+    })
+  )
+});
+async function testEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
+  const startTime = Date.now();
+  const body = JSON.stringify({
+    model,
+    messages: [{ role: "user", content: "say hello and briefly introduce yourself" }],
+    max_tokens: 1024
+  });
+  try {
+    const url = `${baseUrl}${path2}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body
+    });
+    const latencyMs = Date.now() - startTime;
+    const responseText = await response.text();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `HTTP ${response.status}: ${responseText.slice(0, 200)}`,
+        latencyMs
+      };
+    }
+    try {
+      if (isOpenAI) {
+        const json = OpenAIResponseSchema.parse(JSON.parse(responseText));
+        const responseModel = json.model ?? model;
+        const inputTokens = json.usage?.prompt_tokens;
+        const outputTokens = json.usage?.completion_tokens;
+        const content = json.choices?.[0]?.message?.content ?? null;
+        return {
+          success: true,
+          model: responseModel,
+          inputTokens,
+          outputTokens,
+          latencyMs,
+          content: content !== null && content !== "" ? [{ type: "text", text: content }] : void 0,
+          rawResponse: responseText
+        };
+      } else {
+        const json = AnthropicResponseSchema.parse(JSON.parse(responseText));
+        const responseModel = json.model ?? model;
+        const inputTokens = json.usage?.input_tokens;
+        const outputTokens = json.usage?.output_tokens;
+        const content = [];
+        for (const block of json.content ?? []) {
+          if (block.type === "text" && block.text) {
+            content.push({ type: "text", text: block.text });
+          } else if (block.type === "thinking" && block.thinking) {
+            content.push({ type: "thinking", thinking: block.thinking });
+          }
+        }
+        return {
+          success: true,
+          model: responseModel,
+          inputTokens,
+          outputTokens,
+          latencyMs,
+          content: content.length > 0 ? content : void 0,
+          rawResponse: responseText
+        };
+      }
+    } catch (parseErr) {
+      return {
+        success: true,
+        model,
+        latencyMs,
+        content: [{ type: "text", text: responseText.slice(0, 2e3) }],
+        rawResponse: responseText
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: String(err),
+      latencyMs: Date.now() - startTime
+    };
+  }
+}
+async function testStreamingEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
+  const startTime = Date.now();
+  const body = JSON.stringify({
+    model,
+    messages: [{ role: "user", content: "say hello" }],
+    max_tokens: 256,
+    stream: true
+  });
+  try {
+    const url = `${baseUrl}${path2}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body
+    });
+    const latencyMs = Date.now() - startTime;
+    if (!response.ok) {
+      const responseText = await response.text();
+      return {
+        success: false,
+        error: `HTTP ${response.status}: ${responseText.slice(0, 200)}`,
+        latencyMs,
+        streaming: true
+      };
+    }
+    const chunks = [];
+    const reader = response.body?.getReader();
+    if (!reader) {
+      return {
+        success: false,
+        error: "No response body",
+        latencyMs,
+        streaming: true
+      };
+    }
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(decoder.decode(value, { stream: true }));
+      }
+    } catch (readErr) {
+      return {
+        success: false,
+        error: `Stream read error: ${readErr}`,
+        latencyMs,
+        streaming: true
+      };
+    }
+    const fullResponse = chunks.join("");
+    const mockLog = {
+      id: 0,
+      timestamp: "",
+      method: "POST",
+      path: "",
+      model: null,
+      sessionId: null,
+      rawRequestBody: null,
+      responseStatus: null,
+      responseText: null,
+      inputTokens: null,
+      outputTokens: null,
+      cacheCreationInputTokens: null,
+      cacheReadInputTokens: null,
+      elapsedMs: 0,
+      streaming: true,
+      userAgent: null,
+      origin: null,
+      apiFormat: "anthropic",
+      isTest: true
+    };
+    let reconstructedJson;
+    if (isOpenAI) {
+      reconstructedJson = extractOpenAIStream(fullResponse, mockLog, model, true);
+    } else {
+      reconstructedJson = extractAnthropicStream(fullResponse, mockLog, model, true);
+    }
+    const streamingChunks = mockLog.streamingChunks ?? void 0;
+    try {
+      let content = [];
+      let inputTokens;
+      let outputTokens;
+      let responseModel;
+      if (isOpenAI) {
+        const parsed = OpenAIResponseSchema.parse(JSON.parse(reconstructedJson));
+        responseModel = typeof parsed.model === "string" && parsed.model !== "" ? parsed.model : void 0;
+        inputTokens = parsed.usage?.prompt_tokens;
+        outputTokens = parsed.usage?.completion_tokens;
+        const textContent = parsed.choices?.[0]?.message?.content;
+        if (textContent !== null && textContent !== "") {
+          content = [{ type: "text", text: textContent }];
+        }
+      } else {
+        const parsed = AnthropicResponseSchema.parse(JSON.parse(reconstructedJson));
+        responseModel = typeof parsed.model === "string" && parsed.model !== "" ? parsed.model : void 0;
+        inputTokens = parsed.usage?.input_tokens;
+        outputTokens = parsed.usage?.output_tokens;
+        for (const block of parsed.content ?? []) {
+          if (block.type === "text" && block.text) {
+            content.push({ type: "text", text: block.text });
+          } else if (block.type === "thinking" && block.thinking) {
+            content.push({ type: "thinking", thinking: block.thinking });
+          }
+        }
+      }
+      return {
+        success: true,
+        model: responseModel ?? model,
+        inputTokens,
+        outputTokens,
+        latencyMs,
+        content: content.length > 0 ? content : void 0,
+        rawResponse: reconstructedJson,
+        streaming: true,
+        streamingChunks
+      };
+    } catch {
+      return {
+        success: true,
+        model,
+        latencyMs,
+        content: [{ type: "text", text: reconstructedJson.slice(0, 2e3) }],
+        rawResponse: reconstructedJson,
+        streaming: true,
+        streamingChunks
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: String(err),
+      latencyMs: Date.now() - startTime,
+      streaming: true
+    };
+  }
+}
+function createTestLogEntry(providerName, path2, body, upstreamUrl, result, isTest) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    id: `test-${Date.now()}`,
+    method: "POST",
+    path: path2,
+    model: isTest ? result.model : void 0,
+    sessionId: null,
+    rawRequestBody: body,
+    responseStatus: result.success ? 200 : 500,
+    responseText: result.rawResponse ?? JSON.stringify(result),
+    inputTokens: result.inputTokens ?? null,
+    outputTokens: result.outputTokens ?? null,
+    elapsedMs: result.latencyMs ?? 0,
+    streaming: result.streaming ?? false,
+    userAgent: "provider-test",
+    origin: null,
+    upstreamUrl,
+    error: result.success ? null : result.error,
+    isTest: true,
+    providerName
+  };
+}
+const Route$2 = createFileRoute("/api/providers/$providerId/test")({
+  server: {
+    handlers: {
+      POST: async ({ params }) => {
+        const provider = getProvider(params.providerId);
+        if (!provider) {
+          return Response.json({ error: "Provider not found" }, { status: 404 });
+        }
+        if (provider.model === void 0 || provider.model.trim().length === 0) {
+          return Response.json(
+            { error: "Please configure a model name in provider settings" },
+            { status: 400 }
+          );
+        }
+        const model = provider.model.trim();
+        const usageModel = getModelUsageName(model, provider.name);
+        const results = {
+          anthropic: { nonStreaming: { notConfigured: true }, streaming: { notConfigured: true } },
+          openai: { nonStreaming: { notConfigured: true }, streaming: { notConfigured: true } }
+        };
+        if (provider.anthropicBaseUrl !== void 0 && provider.anthropicBaseUrl.length > 0) {
+          const nonStreamingResult = await testEndpoint(
+            provider.anthropicBaseUrl,
+            provider.apiKey,
+            "/v1/messages",
+            usageModel,
+            false
+          );
+          results.anthropic.nonStreaming = nonStreamingResult;
+          const requestBody = JSON.stringify({
+            model: usageModel,
+            messages: [{ role: "user", content: "say hello and briefly introduce yourself" }],
+            max_tokens: 1024
+          });
+          const upstreamUrl = `${provider.anthropicBaseUrl}/v1/messages`;
+          await addTestLogEntry({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            method: "POST",
+            path: "/v1/messages",
+            model: nonStreamingResult.model ?? model,
+            sessionId: null,
+            rawRequestBody: requestBody,
+            responseStatus: nonStreamingResult.success ? 200 : 500,
+            responseText: nonStreamingResult.rawResponse ?? JSON.stringify(nonStreamingResult),
+            inputTokens: nonStreamingResult.inputTokens ?? null,
+            outputTokens: nonStreamingResult.outputTokens ?? null,
+            cacheCreationInputTokens: null,
+            cacheReadInputTokens: null,
+            elapsedMs: nonStreamingResult.latencyMs ?? 0,
+            streaming: false,
+            userAgent: "provider-test",
+            origin: null,
+            apiFormat: "anthropic",
+            isTest: true,
+            providerName: provider.name
+          });
+          appendLogEntry(
+            createTestLogEntry(
+              provider.name,
+              "/v1/messages",
+              requestBody,
+              upstreamUrl,
+              nonStreamingResult,
+              true
+            )
+          );
+          const streamingResult = await testStreamingEndpoint(
+            provider.anthropicBaseUrl,
+            provider.apiKey,
+            "/v1/messages",
+            usageModel,
+            false
+          );
+          results.anthropic.streaming = streamingResult;
+          const streamingRequestBody = JSON.stringify({
+            model: usageModel,
+            messages: [{ role: "user", content: "say hello" }],
+            max_tokens: 256,
+            stream: true
+          });
+          await addTestLogEntry({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            method: "POST",
+            path: "/v1/messages",
+            model: streamingResult.model ?? model,
+            sessionId: null,
+            rawRequestBody: streamingRequestBody,
+            responseStatus: streamingResult.success ? 200 : 500,
+            responseText: streamingResult.rawResponse ?? JSON.stringify(streamingResult),
+            inputTokens: streamingResult.inputTokens ?? null,
+            outputTokens: streamingResult.outputTokens ?? null,
+            cacheCreationInputTokens: null,
+            cacheReadInputTokens: null,
+            elapsedMs: streamingResult.latencyMs ?? 0,
+            streaming: true,
+            streamingChunks: streamingResult.streamingChunks,
+            userAgent: "provider-test",
+            origin: null,
+            apiFormat: "anthropic",
+            isTest: true,
+            providerName: provider.name
+          });
+          appendLogEntry(
+            createTestLogEntry(
+              provider.name,
+              "/v1/messages",
+              streamingRequestBody,
+              upstreamUrl,
+              streamingResult,
+              true
+            )
+          );
+        }
+        if (provider.openaiBaseUrl !== void 0 && provider.openaiBaseUrl.length > 0) {
+          const nonStreamingResult = await testEndpoint(
+            provider.openaiBaseUrl,
+            provider.apiKey,
+            "/v1/chat/completions",
+            usageModel,
+            true
+          );
+          results.openai.nonStreaming = nonStreamingResult;
+          const requestBody = JSON.stringify({
+            model: usageModel,
+            messages: [{ role: "user", content: "say hello and briefly introduce yourself" }],
+            max_tokens: 1024
+          });
+          const upstreamUrl = `${provider.openaiBaseUrl}/v1/chat/completions`;
+          await addTestLogEntry({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            method: "POST",
+            path: "/v1/chat/completions",
+            model: nonStreamingResult.model ?? model,
+            sessionId: null,
+            rawRequestBody: requestBody,
+            responseStatus: nonStreamingResult.success ? 200 : 500,
+            responseText: nonStreamingResult.rawResponse ?? JSON.stringify(nonStreamingResult),
+            inputTokens: nonStreamingResult.inputTokens ?? null,
+            outputTokens: nonStreamingResult.outputTokens ?? null,
+            cacheCreationInputTokens: null,
+            cacheReadInputTokens: null,
+            elapsedMs: nonStreamingResult.latencyMs ?? 0,
+            streaming: false,
+            userAgent: "provider-test",
+            origin: null,
+            apiFormat: "openai",
+            isTest: true,
+            providerName: provider.name
+          });
+          appendLogEntry(
+            createTestLogEntry(
+              provider.name,
+              "/v1/chat/completions",
+              requestBody,
+              upstreamUrl,
+              nonStreamingResult,
+              true
+            )
+          );
+          const streamingResult = await testStreamingEndpoint(
+            provider.openaiBaseUrl,
+            provider.apiKey,
+            "/v1/chat/completions",
+            usageModel,
+            true
+          );
+          results.openai.streaming = streamingResult;
+          const streamingRequestBody = JSON.stringify({
+            model: usageModel,
+            messages: [{ role: "user", content: "say hello" }],
+            max_tokens: 256,
+            stream: true
+          });
+          await addTestLogEntry({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            method: "POST",
+            path: "/v1/chat/completions",
+            model: streamingResult.model ?? model,
+            sessionId: null,
+            rawRequestBody: streamingRequestBody,
+            responseStatus: streamingResult.success ? 200 : 500,
+            responseText: streamingResult.rawResponse ?? JSON.stringify(streamingResult),
+            inputTokens: streamingResult.inputTokens ?? null,
+            outputTokens: streamingResult.outputTokens ?? null,
+            cacheCreationInputTokens: null,
+            cacheReadInputTokens: null,
+            elapsedMs: streamingResult.latencyMs ?? 0,
+            streaming: true,
+            streamingChunks: streamingResult.streamingChunks,
+            userAgent: "provider-test",
+            origin: null,
+            apiFormat: "openai",
+            isTest: true,
+            providerName: provider.name
+          });
+          appendLogEntry(
+            createTestLogEntry(
+              provider.name,
+              "/v1/chat/completions",
+              streamingRequestBody,
+              upstreamUrl,
+              streamingResult,
+              true
+            )
+          );
+        }
+        return Response.json(results);
+      }
+    }
+  }
+});
+const ReplayRequestSchema = object({
+  modifiedBody: string()
+});
+function getHostFromUrl(urlStr) {
+  try {
+    const url = new URL(urlStr);
+    return url.host;
+  } catch {
+    return "api.anthropic.com";
+  }
+}
+function buildUpstreamUrl(upstreamBase, apiPath) {
+  return upstreamBase + apiPath;
+}
+function selectUpstreamBase(isChatCompletions, matchedProviderConfig) {
+  let upstreamBase;
+  if (matchedProviderConfig) {
+    if (isChatCompletions && matchedProviderConfig.openaiBaseUrl !== void 0 && matchedProviderConfig.openaiBaseUrl !== "") {
+      upstreamBase = matchedProviderConfig.openaiBaseUrl;
+    } else if (!isChatCompletions && matchedProviderConfig.anthropicBaseUrl !== void 0 && matchedProviderConfig.anthropicBaseUrl !== "") {
+      upstreamBase = matchedProviderConfig.anthropicBaseUrl;
+    } else if (matchedProviderConfig.baseUrl !== void 0 && matchedProviderConfig.baseUrl !== "") {
+      upstreamBase = matchedProviderConfig.baseUrl;
+    } else {
+      upstreamBase = matchedProviderConfig.format === "openai" ? DEFAULT_OPENAI_UPSTREAM$1 : DEFAULT_UPSTREAM$1;
+    }
+  } else {
+    upstreamBase = isChatCompletions ? DEFAULT_OPENAI_UPSTREAM$1 : DEFAULT_UPSTREAM$1;
+  }
+  return upstreamBase;
+}
+function injectAuthHeaders(upstreamHeaders, matchedProviderConfig) {
+  if (!matchedProviderConfig) return;
+  const apiKey = matchedProviderConfig.apiKey.replace(/^Bearer\s+/i, "").trim();
+  if (matchedProviderConfig.authHeader === AUTH_HEADER_X_API_KEY) {
+    upstreamHeaders.set(HEADER_X_API_KEY, apiKey);
+    upstreamHeaders.delete(HEADER_AUTHORIZATION);
+  } else {
+    upstreamHeaders.set(HEADER_AUTHORIZATION, `Bearer ${apiKey}`);
+  }
+}
+const Route$1 = createFileRoute("/api/logs/$id/replay")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }) => {
+        const id = Number(params.id);
+        if (isNaN(id)) {
+          return Response.json({ error: "Invalid log ID" }, { status: 400 });
+        }
+        let replayRequest;
+        try {
+          const raw = await request.json();
+          const parsed = ReplayRequestSchema.safeParse(raw);
+          if (!parsed.success) {
+            return Response.json({ error: "Invalid request body" }, { status: 400 });
+          }
+          replayRequest = parsed.data;
+        } catch {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+        const { modifiedBody } = replayRequest;
+        const log = await getLogById(id);
+        if (log === null) {
+          return Response.json({ error: "Log not found" }, { status: 404 });
+        }
+        const model = extractModelFromBody(modifiedBody);
+        if (model === null) {
+          return Response.json(
+            { error: "Could not extract model from request body" },
+            { status: 400 }
+          );
+        }
+        const matchedProviderConfig = findProviderByModel(model);
+        const provider = registry.findProvider(model);
+        if (provider === null) {
+          return Response.json(
+            { error: "No provider found for model" },
+            { status: STATUS_FORBIDDEN }
+          );
+        }
+        const apiPath = log.path;
+        const isChatCompletions = apiPath === PATH_V1_CHAT_COMPLETIONS || apiPath === PATH_CHAT_COMPLETIONS;
+        const normalizedPath = isChatCompletions && !apiPath.startsWith("/v1/") ? "/v1" + apiPath : apiPath;
+        const formatHandler = formatForPath(apiPath);
+        if (formatHandler === null) {
+          return Response.json({ error: "Unsupported path" }, { status: STATUS_FORBIDDEN });
+        }
+        const upstreamBase = selectUpstreamBase(isChatCompletions, matchedProviderConfig);
+        const upstreamUrl = buildUpstreamUrl(upstreamBase, normalizedPath);
+        const upstreamHost = getHostFromUrl(upstreamBase);
+        const headers = new Headers();
+        headers.set(HEADER_USER_AGENT, PROXY_IDENTITY);
+        headers.set(HEADER_X_PROXY_IDENTITY, PROXY_IDENTITY);
+        headers.set(HEADER_CONTENT_TYPE, "application/json");
+        for (const name of PRESERVE_HEADERS) {
+          const value = log.rawHeaders?.[name.toLowerCase()];
+          if (value !== void 0) {
+            headers.set(name, value);
+          }
+        }
+        headers.set(HEADER_HOST, upstreamHost);
+        injectAuthHeaders(headers, matchedProviderConfig);
+        const startTime = Date.now();
+        let upstreamRes;
+        try {
+          upstreamRes = await fetch(upstreamUrl, {
+            method: "POST",
+            headers,
+            body: modifiedBody
+          });
+        } catch (err) {
+          return Response.json({
+            success: false,
+            error: String(err)
+          });
+        }
+        const elapsedMs = Date.now() - startTime;
+        const isStream = upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes("text/event-stream") ?? false;
+        if (isStream) {
+          const chunks = [];
+          const decoder = new TextDecoder();
+          const reader = upstreamRes.body?.getReader();
+          if (reader) {
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                chunks.push(decoder.decode(value, { stream: true }));
+              }
+            } catch {
+            }
+          }
+          const fullResponse = chunks.join("");
+          const mockLog = { ...log };
+          const responseText = formatHandler.extractStream(fullResponse, mockLog, model, false);
+          const tokens = formatHandler.extractTokens(responseText);
+          return Response.json({
+            success: true,
+            responseStatus: upstreamRes.status,
+            responseText,
+            inputTokens: tokens.inputTokens ?? void 0,
+            outputTokens: tokens.outputTokens ?? void 0,
+            elapsedMs,
+            streaming: true
+          });
+        } else {
+          const responseText = await upstreamRes.text();
+          const tokens = formatHandler.extractTokens(responseText);
+          return Response.json({
+            success: true,
+            responseStatus: upstreamRes.status,
+            responseText,
+            inputTokens: tokens.inputTokens ?? void 0,
+            outputTokens: tokens.outputTokens ?? void 0,
+            elapsedMs,
+            streaming: false
+          });
+        }
+      }
+    }
+  }
+});
+const Route = createFileRoute("/api/logs/$id/chunks")({
+  server: {
+    handlers: {
+      GET: async ({ params }) => {
+        const id = Number(params.id);
+        if (isNaN(id)) {
+          return Response.json({ error: "Invalid log ID" }, { status: 400 });
+        }
+        const log = await getLogById(id);
+        if (log === null) {
+          return Response.json({ error: "Log not found" }, { status: 404 });
+        }
+        if (log.streamingChunksPath !== null && log.streamingChunksPath !== void 0) {
+          const chunksData = readChunks(log.streamingChunksPath);
+          if (chunksData !== null) {
+            return Response.json(chunksData);
+          }
+        }
+        if (log.streamingChunks !== void 0 && log.streamingChunks.chunks.length > 0) {
+          return Response.json(log.streamingChunks);
+        }
+        return Response.json({ error: "Chunks not found" }, { status: 404 });
+      }
+    }
+  }
+});
+const IndexRoute = Route$d.update({
+  id: "/",
+  path: "/",
+  getParentRoute: () => Route$e
+});
+const ProxySplatRoute = Route$c.update({
+  id: "/proxy/$",
+  path: "/proxy/$",
+  getParentRoute: () => Route$e
+});
+const ApiSessionsRoute = Route$b.update({
+  id: "/api/sessions",
+  path: "/api/sessions",
+  getParentRoute: () => Route$e
+});
+const ApiProvidersRoute = Route$a.update({
+  id: "/api/providers",
+  path: "/api/providers",
+  getParentRoute: () => Route$e
+});
+const ApiModelsRoute = Route$9.update({
+  id: "/api/models",
+  path: "/api/models",
+  getParentRoute: () => Route$e
+});
+const ApiLogsRoute = Route$8.update({
+  id: "/api/logs",
+  path: "/api/logs",
+  getParentRoute: () => Route$e
+});
+const ApiHealthRoute = Route$7.update({
+  id: "/api/health",
+  path: "/api/health",
+  getParentRoute: () => Route$e
+});
+const ApiProvidersProviderIdRoute = Route$6.update({
+  id: "/$providerId",
+  path: "/$providerId",
+  getParentRoute: () => ApiProvidersRoute
+});
+const ApiLogsStreamRoute = Route$5.update({
+  id: "/stream",
+  path: "/stream",
+  getParentRoute: () => ApiLogsRoute
+});
+const ApiLogsIdRoute = Route$4.update({
+  id: "/$id",
+  path: "/$id",
+  getParentRoute: () => ApiLogsRoute
+});
+const ApiConfigPathsRoute = Route$3.update({
+  id: "/api/config/paths",
+  path: "/api/config/paths",
+  getParentRoute: () => Route$e
+});
+const ApiProvidersProviderIdTestRoute = Route$2.update({
+  id: "/test",
+  path: "/test",
+  getParentRoute: () => ApiProvidersProviderIdRoute
+});
+const ApiLogsIdReplayRoute = Route$1.update({
+  id: "/replay",
+  path: "/replay",
+  getParentRoute: () => ApiLogsIdRoute
+});
+const ApiLogsIdChunksRoute = Route.update({
+  id: "/chunks",
+  path: "/chunks",
+  getParentRoute: () => ApiLogsIdRoute
+});
+const ApiLogsIdRouteChildren = {
+  ApiLogsIdChunksRoute,
+  ApiLogsIdReplayRoute
+};
+const ApiLogsIdRouteWithChildren = ApiLogsIdRoute._addFileChildren(
+  ApiLogsIdRouteChildren
+);
+const ApiLogsRouteChildren = {
+  ApiLogsIdRoute: ApiLogsIdRouteWithChildren,
+  ApiLogsStreamRoute
+};
+const ApiLogsRouteWithChildren = ApiLogsRoute._addFileChildren(ApiLogsRouteChildren);
+const ApiProvidersProviderIdRouteChildren = {
+  ApiProvidersProviderIdTestRoute
+};
+const ApiProvidersProviderIdRouteWithChildren = ApiProvidersProviderIdRoute._addFileChildren(
+  ApiProvidersProviderIdRouteChildren
+);
+const ApiProvidersRouteChildren = {
+  ApiProvidersProviderIdRoute: ApiProvidersProviderIdRouteWithChildren
+};
+const ApiProvidersRouteWithChildren = ApiProvidersRoute._addFileChildren(
+  ApiProvidersRouteChildren
+);
+const rootRouteChildren = {
+  IndexRoute,
+  ApiHealthRoute,
+  ApiLogsRoute: ApiLogsRouteWithChildren,
+  ApiModelsRoute,
+  ApiProvidersRoute: ApiProvidersRouteWithChildren,
+  ApiSessionsRoute,
+  ProxySplatRoute,
+  ApiConfigPathsRoute
+};
+const routeTree = Route$e._addFileChildren(rootRouteChildren)._addFileTypes();
+function getRouter() {
+  const router2 = createRouter({
+    routeTree,
+    scrollRestoration: false
+  });
+  return router2;
+}
+const router = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getRouter
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  CapturedLogSchema as C,
+  InspectorResponseSchema as I,
+  parseRequest as a,
+  parseOpenAIResponse as p,
+  router as r
+};