@tonyclaw/llm-inspector 1.7.9 → 1.9.0

package/.output/server/_ssr/{router-CsCLdrXq.mjs → router-CwmgKXBJ.mjs}

@@ -1,13 +1,14 @@
 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 { S as SWRConfig } from "../_libs/swr.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 path, { join, isAbsolute, dirname } from "node:path";
+import { mkdir, appendFile, readFile, writeFile } 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, u as union, a as array, n as number, d as discriminatedUnion, l as literal, b as boolean, r as record, c as lazy, e as _null, f as unknown } from "../_libs/zod.mjs";
+import { o as object, s as string, _ as _enum, u as union, a as array, n as number, d as discriminatedUnion, l as literal, b as boolean, r as record, c as lazy, e as _null, f as unknown } from "../_libs/zod.mjs";
 import "../_libs/tiny-warning.mjs";
 import "../_libs/tanstack__router-core.mjs";
 import "../_libs/cookie-es.mjs";
@@ -22,6 +23,8 @@ import "util";
 import "async_hooks";
 import "stream";
 import "../_libs/isbot.mjs";
+import "../_libs/use-sync-external-store.mjs";
+import "../_libs/dequal.mjs";
 import "node:process";
 import "node:crypto";
 import "node:assert";
@@ -41,7 +44,7 @@ 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 appCss = "/assets/index-DdJSLfxK.css";
 const Route$g = createRootRoute({
   head: () => ({
     meta: [
@@ -60,17 +63,18 @@ 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(SWRConfig, { value: { revalidateOnFocus: false, revalidateIfStale: false }, children }),
       /* @__PURE__ */ jsxRuntimeExports.jsx(Scripts, {})
     ] })
   ] });
 }
-const $$splitComponentImporter = () => import("./index-CAIDMqNv.mjs");
+const $$splitComponentImporter = () => import("./index-COIATcfa.mjs");
 const Route$f = createFileRoute("/")({
   component: lazyRouteComponent($$splitComponentImporter, "component")
 });
 const LOG_DIR_ENV = process.env["LOG_DIR"];
 Number(process.env["LOG_RETENTION_DAYS"] ?? "7");
+const LOG_FILE_ENV = process.env["LLM_INSPECTOR_LOG_FILE"];
 function getUserDataDir() {
   if (process.platform === "win32") {
     return process.env["APPDATA"] ?? path.join(process.env["USERPROFILE"] ?? "C:\\", ".llm-inspector");
@@ -95,18 +99,59 @@ function getLogFilePath() {
   const dd = String(date.getUTCDate()).padStart(2, "0");
   return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
 }
+function getInspectorLogPath() {
+  if (LOG_FILE_ENV !== void 0) {
+    return LOG_FILE_ENV;
+  }
+  const base = getUserDataDir();
+  return path.join(base, ".llm-inspector", "logs", "inspector.log");
+}
+async function writeAppLog(message) {
+  try {
+    const logPath = getInspectorLogPath();
+    const logDirPath = path.dirname(logPath);
+    await mkdir(logDirPath, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    await appendFile(logPath, `[${timestamp}] ${message}
+`, "utf-8");
+  } catch {
+  }
+}
+const logger = {
+  debug(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[DEBUG] ${msg}`);
+  },
+  info(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[INFO] ${msg}`);
+  },
+  warn(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[WARN] ${msg}`);
+  },
+  error(message, ...args) {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[ERROR] ${msg}`);
+  }
+};
+const MAX_BUFFER_SIZE = 1e3;
 let writeBuffer = [];
 let writeScheduled = false;
+let isFlushing = false;
 async function flushWriteBuffer() {
   if (writeBuffer.length === 0) return;
+  if (isFlushing) return;
+  isFlushing = true;
   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);
+  } catch {
+  } finally {
+    isFlushing = false;
   }
 }
 function scheduleFlush() {
@@ -120,7 +165,11 @@ function scheduleFlush() {
 function appendLogEntry(entry) {
   const line = JSON.stringify(entry) + "\n";
   writeBuffer.push(line);
-  scheduleFlush();
+  if (writeBuffer.length >= MAX_BUFFER_SIZE) {
+    void flushWriteBuffer();
+  } else {
+    scheduleFlush();
+  }
 }
 const INDEX_VERSION = 1;
 const INDEX_FILE = "logs.idx";
@@ -159,7 +208,7 @@ async function loadIndex() {
     }
     return cachedIndex;
   } catch (err) {
-    console.error("[logIndex] Failed to load index:", err);
+    logger.error("[logIndex] Failed to load index:", String(err));
     cachedIndex = createEmptyIndex();
     return cachedIndex;
   }
@@ -174,7 +223,7 @@ async function saveIndex(index) {
   try {
     await writeFile(indexPath, JSON.stringify(index), "utf-8");
   } catch (err) {
-    console.error("[logIndex] Failed to save index:", err);
+    logger.error("[logIndex] Failed to save index:", String(err));
   }
 }
 async function addToIndex(id, file, lineStart, lineEnd) {
@@ -183,15 +232,40 @@ async function addToIndex(id, file, lineStart, lineEnd) {
   if (id > index.maxId) {
     index.maxId = id;
   }
+  scheduleIndexFlush();
+}
+let indexFlushScheduled = false;
+async function flushIndexAsync() {
+  indexFlushScheduled = false;
+  const index = await loadIndex();
   await saveIndex(index);
 }
+function scheduleIndexFlush() {
+  if (indexFlushScheduled) return;
+  indexFlushScheduled = true;
+  setTimeout(() => {
+    void flushIndexAsync();
+  }, 1e3);
+}
 async function findInIndex(id) {
   const index = await loadIndex();
   return index.entries[id] ?? null;
 }
+let idGenerationLock = false;
 async function getNextLogId() {
-  const index = await loadIndex();
-  return index.maxId + 1;
+  while (idGenerationLock) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  idGenerationLock = true;
+  try {
+    const index = await loadIndex();
+    const nextId = index.maxId + 1;
+    index.maxId = nextId;
+    cachedIndex = index;
+    return nextId;
+  } finally {
+    idGenerationLock = false;
+  }
 }
 function getCurrentLogFile() {
   const now = /* @__PURE__ */ new Date();
@@ -372,6 +446,13 @@ const SseMessageStopEvent = object({
 const SsePingEvent = object({
   type: literal("ping")
 });
+const SseErrorEvent = object({
+  type: literal("error"),
+  error: object({
+    type: string(),
+    message: string()
+  })
+});
 const SseEventSchema = discriminatedUnion("type", [
   SseMessageStartEvent,
   SseContentBlockStartEvent,
@@ -379,7 +460,8 @@ const SseEventSchema = discriminatedUnion("type", [
   SseContentBlockStopEvent,
   SseMessageDeltaEvent,
   SseMessageStopEvent,
-  SsePingEvent
+  SsePingEvent,
+  SseErrorEvent
 ]);
 const InspectorRequestSchema = AnthropicRequestSchema;
 const InspectorResponseSchema = AnthropicResponseSchema$1;
@@ -538,7 +620,9 @@ const CapturedLogSchema = object({
   clientCwd: string().nullable().optional(),
   clientProjectFolder: string().nullable().optional(),
   streamingChunks: StreamingChunksArraySchema.optional(),
-  streamingChunksPath: string().nullable().optional()
+  streamingChunksPath: string().nullable().optional(),
+  /** Error message from streaming response (e.g., SSE error event) */
+  error: string().nullable().optional()
 });
 const RequestModelSchema = object({
   model: string()
@@ -598,13 +682,13 @@ function writeChunks(logId, chunks, truncated) {
   try {
     mkdirSync(dir, { recursive: true });
   } catch (err) {
-    console.error("[chunkStorage] Failed to create chunks directory:", err);
+    logger.error("[chunkStorage] Failed to create chunks directory:", String(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);
+    logger.error("[chunkStorage] Failed to write chunks temp file:", String(err));
     return targetPath;
   }
   try {
@@ -615,7 +699,7 @@ function writeChunks(logId, chunks, truncated) {
       copyFileSync(tempPath, targetPath);
       unlinkSync(tempPath);
     } catch (copyErr) {
-      console.error("[chunkStorage] Failed to copy chunks file:", copyErr);
+      logger.error("[chunkStorage] Failed to copy chunks file:", String(copyErr));
     }
   }
   return targetPath;
@@ -788,12 +872,12 @@ async function getLogById(id) {
     }
     if (lastMatch !== null) return lastMatch;
   } catch (err) {
-    console.error("[store] Failed to read log from disk:", err);
+    logger.error("[store] Failed to read log from disk:", String(err));
   }
   return null;
 }
 function getFilteredLogs(sessionId, model) {
-  const cachedLogs = Array.from(memoryCache.values()).sort((a, b) => a.id - b.id);
+  const cachedLogs = Array.from(memoryCache.values());
   return cachedLogs.filter((l) => {
     if (sessionId !== void 0 && l.sessionId !== sessionId) return false;
     if (model !== void 0 && l.model !== model) return false;
@@ -1006,6 +1090,15 @@ function extractAnthropicStream(raw, log, fallbackModel, collectChunks) {
           stopSequence = data.delta.stop_sequence ?? null;
           outputTokens = data.usage.output_tokens;
           log.outputTokens = outputTokens;
+          if (data.usage.cache_creation_input_tokens !== void 0) {
+            log.cacheCreationInputTokens = data.usage.cache_creation_input_tokens;
+          }
+          if (data.usage.cache_read_input_tokens !== void 0) {
+            log.cacheReadInputTokens = data.usage.cache_read_input_tokens;
+          }
+          break;
+        case "error":
+          log.error = data.error.message;
           break;
         case "content_block_stop":
         case "message_stop":
@@ -1182,6 +1275,16 @@ function extractOpenAIStream(raw, log, fallbackModel, collectChunks = true) {
     if (dataStr === "[DONE]") break;
     try {
       const parsed = JSON.parse(dataStr);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        const errorDesc = Object.getOwnPropertyDescriptor(parsed, "error");
+        if (errorDesc !== void 0 && typeof errorDesc.value === "object" && errorDesc.value !== null) {
+          const msgDesc = Object.getOwnPropertyDescriptor(errorDesc.value, "message");
+          if (msgDesc !== void 0 && typeof msgDesc.value === "string") {
+            log.error = msgDesc.value;
+          }
+          continue;
+        }
+      }
       const chunkResult = OpenAISSERawChunkSchema.safeParse(parsed);
       if (!chunkResult.success) continue;
       const chunk = chunkResult.data;
@@ -1392,6 +1495,8 @@ const ProviderConfigSchema = object({
   openaiBaseUrl: string().optional(),
   /** Auth header to use: "bearer" (default) or "x-api-key" */
   authHeader: _enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  /** API documentation URL */
+  apiDocsUrl: string().optional(),
   createdAt: string(),
   updatedAt: string()
 });
@@ -1470,7 +1575,7 @@ function getProvider(id) {
 function normalizeApiKey(apiKey) {
   return apiKey.replace(/^Bearer\s+/i, "").trim();
 }
-function addProvider(name, apiKey, format, baseUrl, model, authHeader) {
+function addProvider(name, apiKey, format, baseUrl, model, authHeader, apiDocsUrl) {
   const providers = getProviders();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const newProvider = {
@@ -1481,6 +1586,7 @@ function addProvider(name, apiKey, format, baseUrl, model, authHeader) {
     baseUrl,
     model,
     authHeader: authHeader ?? "bearer",
+    apiDocsUrl,
     createdAt: now,
     updatedAt: now,
     anthropicBaseUrl: format === "anthropic" && baseUrl !== void 0 ? baseUrl : "",
@@ -1502,6 +1608,7 @@ function updateProvider(id, updates) {
     format: updates.format ?? existing.format,
     baseUrl: updates.baseUrl !== void 0 ? updates.baseUrl : existing.baseUrl,
     authHeader: updates.authHeader ?? existing.authHeader,
+    apiDocsUrl: updates.apiDocsUrl ?? existing.apiDocsUrl,
     createdAt: existing.createdAt,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     // Handle format-specific URLs
@@ -1633,45 +1740,99 @@ function extractRemotePort(request) {
   return null;
 }
 async function lookupPidByPort(port) {
+  const platform = process.platform;
   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;
+    if (platform === "win32") {
+      const { stdout } = await execAsync(
+        `powershell -NoProfile -Command "Get-NetTCPConnection -LocalPort ${port} -State Established | Select-Object -ExpandProperty OwningProcess"`,
+        { windowsHide: true }
+      );
+      const pid = parseInt(stdout.trim(), 10);
+      return !isNaN(pid) && pid > 0 ? pid : null;
+    } else if (platform === "darwin") {
+      const { stdout } = await execAsync(`lsof -i :${port} -sTCP:ESTABLISHED -t 2>/dev/null`, {
+        shell: "/bin/sh"
+      });
+      const pid = parseInt(stdout.trim(), 10);
+      return !isNaN(pid) && pid > 0 ? pid : null;
+    } else {
+      try {
+        const { stdout: stdout2 } = await execAsync(
+          `ss -tlnp 'sport = :${port}' 2>/dev/null | grep ESTAB | awk '{print $6}' | grep -o 'pid=[0-9]*' | cut -d= -f2`,
+          { shell: "/bin/sh" }
+        );
+        const pid2 = parseInt(stdout2.trim(), 10);
+        if (!isNaN(pid2) && pid2 > 0) return pid2;
+      } catch {
       }
+      const { stdout } = await execAsync(
+        `netstat -tan 2>/dev/null | grep ':${port}' | grep ESTABLISHED | awk '{print $7}' | cut -d/ -f1`,
+        { shell: "/bin/sh" }
+      );
+      const pid = parseInt(stdout.trim(), 10);
+      return !isNaN(pid) && pid > 0 ? pid : null;
     }
-    return null;
-  } catch {
+  } catch (err) {
+    logger.debug(`[socketTracker] Failed to lookup PID for port ${port}:`, String(err));
     return null;
   }
 }
 async function lookupProcessInfo(pid) {
+  const platform = process.platform;
   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 (platform === "win32") {
+      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
+              };
+            }
+          }
+        }
+      }
+    } else {
+      try {
+        const { stdout } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\\0' ' '`, {
+          shell: "/bin/sh"
+        });
+        const commandLine = stdout.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("\\"));
+            const exeDir = exePath.substring(0, exePath.lastIndexOf("/"));
             return {
               cwd: exeDir,
-              projectFolder: exeDir.split("\\").pop() ?? null
+              projectFolder: exeDir.split("/").pop() ?? null
             };
           }
         }
+      } catch {
+      }
+      if (platform === "darwin") {
+        const { stdout } = await execAsync(`ps -p ${pid} -o comm= 2>/dev/null`, {
+          shell: "/bin/sh"
+        });
+        const exePath = stdout.trim();
+        if (exePath) {
+          const exeDir = exePath.substring(0, exePath.lastIndexOf("/"));
+          return {
+            cwd: exeDir,
+            projectFolder: exePath.split("/").pop() ?? null
+          };
+        }
       }
     }
     return { cwd: null, projectFolder: null };
@@ -1744,7 +1905,8 @@ function buildFileLogEntry(log, upstreamUrl) {
     clientCwd: log.clientCwd,
     clientProjectFolder: log.clientProjectFolder,
     streamingChunks: log.streamingChunks,
-    streamingChunksPath: log.streamingChunksPath
+    streamingChunksPath: log.streamingChunksPath,
+    error: log.error
   };
 }
 function parseRequestPath(req, url) {
@@ -1837,7 +1999,7 @@ function handleStreamingResponse(upstreamRes, req, startTime, formatHandler, ups
         );
         log.streamingChunksPath = chunkPath;
       }
-      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: null });
+      appendLogEntry(buildFileLogEntry(log, upstreamUrl));
       emitLogUpdate(log);
     }
   });
@@ -1846,17 +2008,22 @@ function handleStreamingResponse(upstreamRes, req, startTime, formatHandler, ups
   }
   const loggedStream = upstreamRes.body.pipeThrough(transform);
   req.signal?.addEventListener("abort", () => {
-    if (log.responseText === null && chunks.length > 0) {
-      const full = chunks.join("");
+    if (log.responseText === null) {
+      logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
       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;
+      if (chunks.length > 0) {
+        const full = chunks.join("");
+        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;
+        }
+      } else {
+        log.responseText = "Client aborted";
       }
       appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
       emitLogUpdate(log);
@@ -1878,7 +2045,7 @@ async function handleProxy(req) {
     requestBody = await req.text();
   }
   const model = requestBody !== null ? extractModelFromBody(requestBody) : null;
-  const matchedProviderConfig = findProviderByModelFromConfig(requestBody);
+  const matchedProviderConfig = model !== null ? findProviderByModel(model) : null;
   const upstreamBase = selectUpstreamBase$1(parsed.isChatCompletions, matchedProviderConfig);
   const upstreamUrl = buildUpstreamUrl$1(upstreamBase, parsed.normalizedPath);
   const upstreamHost = getHostFromUrl$1(upstreamBase);
@@ -1888,6 +2055,7 @@ async function handleProxy(req) {
   injectAuthHeaders$1(upstreamHeaders, matchedProviderConfig);
   const provider = model !== null ? registry.findProvider(model) : null;
   if (model === null || provider === null) {
+    logger.warn(`[handler] Unsupported provider: model=${model}`);
     return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
   }
   let formatHandler;
@@ -1919,10 +2087,19 @@ async function handleProxy(req) {
     upstreamRes = await fetch(upstreamUrl, {
       method: req.method,
       headers: upstreamHeaders,
-      body: requestBody
+      body: requestBody,
+      signal: req.signal
     });
   } catch (err) {
     log.elapsedMs = Date.now() - startTime;
+    if (err instanceof Error && err.name === "AbortError") {
+      logger.info(`[handler] Client aborted: ${req.method} ${parsed.apiPath}`);
+      log.responseStatus = 499;
+      log.responseText = "Client aborted";
+      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
+      return new Response("Client aborted", { status: 499 });
+    }
+    logger.error(`[handler] Proxy error: ${req.method} ${parsed.apiPath}`, String(err));
     log.responseStatus = STATUS_BAD_GATEWAY;
     log.responseText = String(err);
     appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: String(err) });
@@ -1942,12 +2119,6 @@ async function handleProxy(req) {
   }
   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$e = createFileRoute("/proxy/$")({
   server: {
     handlers: {
@@ -1973,7 +2144,8 @@ const ProviderInputSchema = object({
   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")
+  authHeader: _enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  apiDocsUrl: string().optional()
 });
 const Route$c = createFileRoute("/api/providers")({
   server: {
@@ -1992,7 +2164,8 @@ const Route$c = createFileRoute("/api/providers")({
           parsed.data.format,
           parsed.data.baseUrl,
           parsed.data.model,
-          parsed.data.authHeader
+          parsed.data.authHeader,
+          parsed.data.apiDocsUrl
         );
         return Response.json(newProvider, { status: 201 });
       }
@@ -2100,7 +2273,8 @@ const ProviderUpdateSchema = object({
   model: string().min(1, "Model is required").optional(),
   authHeader: _enum(["bearer", "x-api-key"]).optional(),
   anthropicBaseUrl: string().optional(),
-  openaiBaseUrl: string().optional()
+  openaiBaseUrl: string().optional(),
+  apiDocsUrl: string().optional()
 });
 const Route$6 = createFileRoute("/api/providers/$providerId")({
   server: {
@@ -2306,7 +2480,7 @@ function truncateErrorDetails(details) {
   }
   return details.slice(0, MAX_ERROR_DETAILS_LENGTH) + "...";
 }
-function createErrorResult(error, latencyMs, streaming, responseStatus) {
+function createErrorResult(error, latencyMs, streaming, responseStatus, requestHeaders) {
   const { type, details } = classifyError(error, responseStatus);
   return {
     success: false,
@@ -2317,7 +2491,8 @@ function createErrorResult(error, latencyMs, streaming, responseStatus) {
       hint: ERROR_HINTS[type]
     },
     latencyMs,
-    streaming
+    streaming,
+    requestHeaders
   };
 }
 function getErrorMessage(type) {
@@ -2394,7 +2569,8 @@ async function testEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
         `HTTP ${response.status}: ${response.statusText}`,
         latencyMs,
         false,
-        response.status
+        response.status,
+        requestHeaders
       );
     }
     const responseText = await response.text();
@@ -2451,7 +2627,7 @@ async function testEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
     }
   } catch (err) {
     clearTimeout(timeoutId);
-    return createErrorResult(err, Date.now() - startTime, false);
+    return createErrorResult(err, Date.now() - startTime, false, void 0, requestHeaders);
   }
 }
 async function testStreamingEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
@@ -2483,7 +2659,8 @@ async function testStreamingEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
         `HTTP ${response.status}: ${response.statusText}`,
         latencyMs,
         true,
-        response.status
+        response.status,
+        requestHeaders
       );
     }
     const chunks = [];
@@ -2511,7 +2688,9 @@ async function testStreamingEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
           return createErrorResult(
             "Response too large (exceeded 10MB limit)",
             Date.now() - startTime,
-            true
+            true,
+            void 0,
+            requestHeaders
           );
         }
         const decoded = decoder.decode(value, { stream: true });
@@ -2523,7 +2702,13 @@ async function testStreamingEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
         chunks.push(finalChunk);
       }
     } catch (readErr) {
-      return createErrorResult(`Stream read error: ${readErr}`, latencyMs, true);
+      return createErrorResult(
+        `Stream read error: ${readErr}`,
+        latencyMs,
+        true,
+        void 0,
+        requestHeaders
+      );
     }
     const fullResponse = chunks.join("");
     const mockLog = {
@@ -2607,7 +2792,7 @@ async function testStreamingEndpoint(baseUrl, apiKey, path2, model, isOpenAI) {
     }
   } catch (err) {
     clearTimeout(timeoutId);
-    return createErrorResult(err, Date.now() - startTime, true);
+    return createErrorResult(err, Date.now() - startTime, true, void 0, requestHeaders);
   }
 }
 function createTestLogEntry(providerName, path2, body, upstreamUrl, result, isTest) {