@tonyclaw/llm-inspector 1.8.0 → 1.9.0

package/src/proxy/handler.ts

@@ -1,5 +1,5 @@
 import { createLog, emitLogUpdate, type CapturedLog } from "./store";
-import { appendLogEntry } from "./logger";
+import { appendLogEntry, logger } from "./logger";
 import { writeChunks } from "./chunkStorage";
 import { extractModelFromBody, type RequestFormat } from "./schemas";
 import { registry } from "./formats";
@@ -89,6 +89,7 @@ function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string
     clientProjectFolder: log.clientProjectFolder,
     streamingChunks: log.streamingChunks,
     streamingChunksPath: log.streamingChunksPath,
+    error: log.error,
   };
 }
 
@@ -252,7 +253,7 @@ function handleStreamingResponse(
         );
         log.streamingChunksPath = chunkPath;
       }
-      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: null });
+      appendLogEntry(buildFileLogEntry(log, upstreamUrl));
       emitLogUpdate(log);
     },
   });
@@ -264,18 +265,23 @@ function handleStreamingResponse(
   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 ?? undefined, true);
-      // Persist chunks to disk on abort
-      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 ?? undefined, true);
+        // Persist chunks to disk on abort
+        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);
@@ -296,15 +302,17 @@ export async function handleProxy(req: Request): Promise<Response> {
   const url = new URL(req.url);
   const parsed = parseRequestPath(req, url);
 
+  // Read body only after cheap path checks
   let requestBody: string | null = null;
   if (req.body && req.method !== "GET" && req.method !== "HEAD") {
     requestBody = await req.text();
   }
 
-  // Extract model once and reuse
+  // Extract model once and reuse - avoid duplicate parsing
   const model = requestBody !== null ? extractModelFromBody(requestBody) : null;
 
-  const matchedProviderConfig = findProviderByModelFromConfig(requestBody);
+  // Find provider config using already-extracted model (not calling extractModelFromBody again)
+  const matchedProviderConfig = model !== null ? findProviderByModel(model) : null;
   const upstreamBase = selectUpstreamBase(parsed.isChatCompletions, matchedProviderConfig);
   const upstreamUrl = buildUpstreamUrl(upstreamBase, parsed.normalizedPath);
   const upstreamHost = getHostFromUrl(upstreamBase);
@@ -318,6 +326,7 @@ export async function handleProxy(req: Request): Promise<Response> {
 
   // Only proxy requests matching a registered provider
   if (model === null || provider === null) {
+    logger.warn(`[handler] Unsupported provider: model=${model}`);
     return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
   }
 
@@ -354,9 +363,19 @@ export async function handleProxy(req: Request): Promise<Response> {
       method: req.method,
       headers: upstreamHeaders,
       body: requestBody,
+      signal: req.signal,
     });
   } catch (err) {
     log.elapsedMs = Date.now() - startTime;
+    // Check if it was a client abort (not a proxy error)
+    if (err instanceof Error && err.name === "AbortError") {
+      logger.info(`[handler] Client aborted: ${req.method} ${parsed.apiPath}`);
+      log.responseStatus = 499; // Client Closed Request (non-standard but descriptive)
+      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) });
@@ -380,15 +399,3 @@ export async function handleProxy(req: Request): Promise<Response> {
 
   return handleStreamingResponse(upstreamRes, req, startTime, formatHandler, upstreamUrl, log);
 }
-
-/**
- * Find provider configuration by model name (from persistent store).
- */
-function findProviderByModelFromConfig(
-  requestBody: string | null,
-): ReturnType<typeof findProviderByModel> {
-  if (requestBody === null) return null;
-  const model = extractModelFromBody(requestBody);
-  if (model === null) return null;
-  return findProviderByModel(model);
-}

package/src/proxy/logIndex.ts

@@ -2,7 +2,7 @@ import { readFile, writeFile, stat, readdir, mkdir } from "node:fs/promises";
 import { createReadStream, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { createInterface } from "node:readline";
-import { resolveLogDir } from "./logger";
+import { resolveLogDir, logger } from "./logger";
 
 type LogIndexEntry = {
   id: number;
@@ -71,8 +71,7 @@ export async function loadIndex(): Promise<LogIndex> {
     }
     return cachedIndex;
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[logIndex] Failed to load index:", err);
+    logger.error("[logIndex] Failed to load index:", String(err));
     cachedIndex = createEmptyIndex();
     return cachedIndex;
   }
@@ -91,8 +90,7 @@ export async function saveIndex(index: LogIndex): Promise<void> {
   try {
     await writeFile(indexPath, JSON.stringify(index), "utf-8");
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[logIndex] Failed to save index:", err);
+    logger.error("[logIndex] Failed to save index:", String(err));
   }
 }
 
@@ -107,6 +105,36 @@ export async function addToIndex(
   if (id > index.maxId) {
     index.maxId = id;
   }
+  // Defer disk writes to reduce I/O - flush after a batch of updates
+  scheduleIndexFlush();
+}
+
+// Batch writes: collect pending flushes and write once
+let indexFlushScheduled = false;
+let indexFlushTimeout: ReturnType<typeof setTimeout> | null = null;
+
+async function flushIndexAsync(): Promise<void> {
+  indexFlushScheduled = false;
+  indexFlushTimeout = null;
+  const index = await loadIndex();
+  await saveIndex(index);
+}
+
+function scheduleIndexFlush(): void {
+  if (indexFlushScheduled) return;
+  indexFlushScheduled = true;
+  indexFlushTimeout = setTimeout(() => {
+    void flushIndexAsync();
+  }, 1000); // Flush after 1 second of inactivity
+}
+
+export async function flushIndex(): Promise<void> {
+  if (indexFlushTimeout !== null) {
+    clearTimeout(indexFlushTimeout);
+    indexFlushTimeout = null;
+  }
+  indexFlushScheduled = false;
+  const index = await loadIndex();
   await saveIndex(index);
 }
 
@@ -173,9 +201,26 @@ export async function rebuildIndex(): Promise<LogIndex> {
   return newIndex;
 }
 
+// Mutex for atomic ID generation to prevent race conditions
+let idGenerationLock = false;
+
 export async function getNextLogId(): Promise<number> {
-  const index = await loadIndex();
-  return index.maxId + 1;
+  // Wait for any ongoing ID generation to complete
+  while (idGenerationLock) {
+    // Use setTimeout(0) to yield to event loop
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  idGenerationLock = true;
+  try {
+    const index = await loadIndex();
+    const nextId = index.maxId + 1;
+    index.maxId = nextId;
+    // Synchronously update the index in memory (disk write is deferred via batching)
+    cachedIndex = index;
+    return nextId;
+  } finally {
+    idGenerationLock = false;
+  }
 }
 
 export function getCurrentLogFile(): string {

package/src/proxy/logger.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 
 const LOG_DIR_ENV = process.env["LOG_DIR"];
 const RETENTION_DAYS = Number(process.env["LOG_RETENTION_DAYS"] ?? "7");
+const LOG_FILE_ENV = process.env["LLM_INSPECTOR_LOG_FILE"];
 
 function getUserDataDir(): string {
   if (process.platform === "win32") {
@@ -35,6 +36,14 @@ export function getLogFilePath(): string {
   return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
 }
 
+function getInspectorLogPath(): string {
+  if (LOG_FILE_ENV !== undefined) {
+    return LOG_FILE_ENV;
+  }
+  const base = getUserDataDir();
+  return path.join(base, ".llm-inspector", "logs", "inspector.log");
+}
+
 export async function initLogger(): Promise<void> {
   const dir = resolveLogDir();
   const retentionMs = RETENTION_DAYS * 24 * 60 * 60 * 1000;
@@ -50,24 +59,59 @@ export async function initLogger(): Promise<void> {
         if (s.mtimeMs < cutoff) {
           await unlink(fullPath);
         }
-      } catch (err) {
-        // eslint-disable-next-line no-console
-        console.error("[logger] Failed to stat/remove log file:", err);
+      } catch {
+        // Skip files that can't be stat
       }
     }
-  } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[logger] Failed to initialize logger:", err);
+  } catch {
+    // Skip directory initialization errors
+  }
+}
+
+// File-based logger for application logs (not log entries)
+async function writeAppLog(message: string): Promise<void> {
+  try {
+    const logPath = getInspectorLogPath();
+    const logDirPath = path.dirname(logPath);
+    await mkdir(logDirPath, { recursive: true });
+    const timestamp = new Date().toISOString();
+    await appendFile(logPath, `[${timestamp}] ${message}\n`, "utf-8");
+  } catch {
+    // Silently fail if we can't write to log
   }
 }
 
+// Application logger - writes to inspector.log
+export const logger = {
+  debug(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[DEBUG] ${msg}`);
+  },
+  info(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[INFO] ${msg}`);
+  },
+  warn(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[WARN] ${msg}`);
+  },
+  error(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[ERROR] ${msg}`);
+  },
+};
+
 // Write buffer for batching async writes
+const MAX_BUFFER_SIZE = 1000; // Prevent unbounded memory growth
 let writeBuffer: string[] = [];
 let writeScheduled = false;
+let isFlushing = false; // Prevent concurrent flush operations
 
 async function flushWriteBuffer(): Promise<void> {
   if (writeBuffer.length === 0) return;
+  if (isFlushing) return; // Skip if another flush is in progress
 
+  isFlushing = true;
   const toWrite = writeBuffer.join("");
   writeBuffer = [];
 
@@ -75,9 +119,10 @@ async function flushWriteBuffer(): Promise<void> {
     const filePath = getLogFilePath();
     await mkdir(path.dirname(filePath), { recursive: true });
     await appendFile(filePath, toWrite, "utf-8");
-  } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[logger] Failed to write log entries:", err);
+  } catch {
+    // Silently fail write buffer errors
+  } finally {
+    isFlushing = false;
   }
 }
 
@@ -95,5 +140,10 @@ function scheduleFlush(): void {
 export function appendLogEntry(entry: Record<string, unknown>): void {
   const line = JSON.stringify(entry) + "\n";
   writeBuffer.push(line);
-  scheduleFlush();
+  // Flush immediately if buffer exceeds max size to prevent OOM
+  if (writeBuffer.length >= MAX_BUFFER_SIZE) {
+    void flushWriteBuffer();
+  } else {
+    scheduleFlush();
+  }
 }

package/src/proxy/providers.ts

@@ -17,6 +17,8 @@ export const ProviderConfigSchema = z.object({
   openaiBaseUrl: z.string().optional(),
   /** Auth header to use: "bearer" (default) or "x-api-key" */
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  /** API documentation URL */
+  apiDocsUrl: z.string().optional(),
   createdAt: z.string(),
   updatedAt: z.string(),
 });
@@ -142,6 +144,7 @@ export function addProvider(
   baseUrl?: string,
   model?: string,
   authHeader?: "bearer" | "x-api-key",
+  apiDocsUrl?: string,
 ): ProviderConfig {
   const providers = getProviders();
   const now = new Date().toISOString();
@@ -153,6 +156,7 @@ export function addProvider(
     baseUrl,
     model,
     authHeader: authHeader ?? "bearer",
+    apiDocsUrl,
     createdAt: now,
     updatedAt: now,
     anthropicBaseUrl: format === "anthropic" && baseUrl !== undefined ? baseUrl : "",
@@ -179,6 +183,7 @@ export function updateProvider(
     format: updates.format ?? existing.format,
     baseUrl: updates.baseUrl !== undefined ? updates.baseUrl : existing.baseUrl,
     authHeader: updates.authHeader ?? existing.authHeader,
+    apiDocsUrl: updates.apiDocsUrl ?? existing.apiDocsUrl,
     createdAt: existing.createdAt,
     updatedAt: new Date().toISOString(),
     // Handle format-specific URLs

package/src/proxy/schemas.ts

@@ -61,6 +61,8 @@ export const CapturedLogSchema = z.object({
   clientProjectFolder: z.string().nullable().optional(),
   streamingChunks: StreamingChunksArraySchema.optional(),
   streamingChunksPath: z.string().nullable().optional(),
+  /** Error message from streaming response (e.g., SSE error event) */
+  error: z.string().nullable().optional(),
 });
 
 export type CapturedLog = z.infer<typeof CapturedLogSchema>;

package/src/proxy/socketTracker.ts

@@ -1,5 +1,6 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { logger } from "./logger";
 
 const execAsync = promisify(exec);
 
@@ -55,30 +56,49 @@ function extractRemotePort(request: Request): number | null {
 }
 
 /**
- * Look up PID from a local port using netstat.
+ * Look up PID from a local port using platform-appropriate command.
  * Returns PID as number, or null if not found.
  */
 async function lookupPidByPort(port: number): Promise<number | null> {
+  const platform = process.platform;
+
   try {
-    // netstat -aon finds all connections with port, -n avoids DNS resolution
-    // Filter by ESTABLISHED connections on the specific port
-    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) {
-      // Format: TCP    127.0.0.1:12345    127.0.0.1:54321    ESTABLISHED    12345
-      // The last space-separated token is the PID
-      const parts = line.trim().split(/\s+/);
-      const lastPart = parts[parts.length - 1];
-      if (lastPart !== undefined) {
-        const pid = parseInt(lastPart, 10);
+    if (platform === "win32") {
+      // Windows: use PowerShell Get-NetTCPConnection (faster than netstat)
+      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") {
+      // macOS: use lsof
+      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 {
+      // Linux: use ss (faster than netstat) or fall back to netstat
+      try {
+        const { stdout } = 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 pid = parseInt(stdout.trim(), 10);
         if (!isNaN(pid) && pid > 0) return pid;
+      } catch {
+        // Fall back to netstat
       }
+      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;
   }
 }
@@ -90,35 +110,69 @@ async function lookupPidByPort(port: number): Promise<number | null> {
 async function lookupProcessInfo(
   pid: number,
 ): Promise<{ cwd: string | null; projectFolder: string | null }> {
+  const platform = process.platform;
+
   try {
-    // Use wmic to get the full command line
-    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") {
+      // Windows: use wmic
+      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] !== undefined) {
+              const exePath = exeMatch[1];
+              const exeDir = exePath.substring(0, exePath.lastIndexOf("\\"));
+              return {
+                cwd: exeDir,
+                projectFolder: exeDir.split("\\").pop() ?? null,
+              };
+            }
+          }
+        }
+      }
+    } else {
+      // Unix/Linux/macOS: read from /proc or use ps
+      try {
+        // Try reading /proc/PID/cmdline (Linux)
+        const { stdout } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\\0' ' '`, {
+          shell: "/bin/sh",
+        });
+        const commandLine = stdout.trim();
         if (commandLine) {
-          // Extract CWD from command line
-          // The command typically looks like: "C:\path\to\ai-tool\resources\app\bin\cli\win32-x64\tool.exe" ...
-          // or "C:\Users\user\AppData\Local\Programs\Claude\Claude.exe" --some-flag
-          // We need to find the working directory - it's usually the directory containing the exe
-          // but we also need to check if a --parent-dir flag was passed
-
-          // Parse the command line to find the executable path
           const exeMatch = commandLine.match(/^"([^"]+)"/) || commandLine.match(/^([^\s]+)/);
           if (exeMatch && exeMatch[1] !== undefined) {
             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 {
+        // Fall back to ps
+      }
+
+      // macOS fallback
+      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 };

package/src/proxy/store.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { readFileSync, existsSync } from "node:fs";
-import { createReadStream } from "node:fs";
+import { readFileSync, existsSync, createReadStream } from "node:fs";
+import { readdir as readdirCallback } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { join } from "node:path";
-import { appendLogEntry, resolveLogDir } from "./logger";
+import { appendLogEntry, resolveLogDir, logger } from "./logger";
 import {
   addToIndex,
   findInIndex,
@@ -258,16 +258,15 @@ export async function getLogById(id: number): Promise<CapturedLog | null> {
     // Fallback: return the last matching entry (incomplete is better than nothing)
     if (lastMatch !== null) return lastMatch;
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[store] Failed to read log from disk:", err);
+    logger.error("[store] Failed to read log from disk:", String(err));
   }
 
   return null;
 }
 
 export function getFilteredLogs(sessionId?: string, model?: string): CapturedLog[] {
-  // Get all logs from memory cache sorted by ID
-  const cachedLogs = Array.from(memoryCache.values()).sort((a, b) => a.id - b.id);
+  // Cache maintains insertion order (sorted by ID since logs are added in ID order)
+  const cachedLogs = Array.from(memoryCache.values());
 
   return cachedLogs.filter((l) => {
     if (sessionId !== undefined && l.sessionId !== sessionId) return false;
@@ -293,20 +292,32 @@ export function getModels(): string[] {
 }
 
 /**
- * Load recent completed log entries from today's log file into the memory cache.
+ * Load recent completed log entries from all log files into the memory cache.
  * Called on server startup so the frontend shows existing logs.
  */
 export async function loadLogsIntoMemory(): Promise<void> {
   const logDir = resolveLogDir();
   if (!existsSync(logDir)) return;
 
-  const today = getCurrentLogFile();
-  const filePath = join(logDir, today);
-  if (!existsSync(filePath)) return;
-
   // Keep track of IDs seen so we only load the completed entry for each
   const seenComplete = new Set<number>();
 
+  // Get all .jsonl files sorted by name (date)
+  try {
+    const entries = await readdirCallback(logDir);
+    const filesWithExt = entries.filter((f: string) => f.endsWith(".jsonl")).sort();
+    for (const file of filesWithExt) {
+      const filePath = join(logDir, file);
+      await loadLogFile(filePath, seenComplete);
+    }
+  } catch (err) {
+    logger.error("[store] Failed to read log directory:", String(err));
+  }
+}
+
+async function loadLogFile(filePath: string, seenComplete: Set<number>): Promise<void> {
+  if (!existsSync(filePath)) return;
+
   try {
     const fileStream = createInterface({
       input: createReadStream(filePath),
@@ -348,8 +359,7 @@ export async function loadLogsIntoMemory(): Promise<void> {
       }
     }
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[store] Failed to load logs into memory:", err);
+    logger.error("[store] Failed to load logs into memory:", String(err));
   }
 }
 

package/src/routes/api/providers.$providerId.ts

@@ -11,6 +11,7 @@ const ProviderUpdateSchema = z.object({
   authHeader: z.enum(["bearer", "x-api-key"]).optional(),
   anthropicBaseUrl: z.string().optional(),
   openaiBaseUrl: z.string().optional(),
+  apiDocsUrl: z.string().optional(),
 });
 
 export const Route = createFileRoute("/api/providers/$providerId")({

package/src/routes/api/providers.ts

@@ -9,6 +9,7 @@ const ProviderInputSchema = z.object({
   baseUrl: z.string().min(1, "Base URL is required"),
   model: z.string().min(1, "Model is required"),
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  apiDocsUrl: z.string().optional(),
 });
 
 export const Route = createFileRoute("/api/providers")({
@@ -29,6 +30,7 @@ export const Route = createFileRoute("/api/providers")({
           parsed.data.baseUrl,
           parsed.data.model,
           parsed.data.authHeader,
+          parsed.data.apiDocsUrl,
         );
         return Response.json(newProvider, { status: 201 });
       },