@tonyclaw/llm-inspector 1.11.4 → 1.11.6

package/src/components/providers/ProviderCard.tsx

@@ -1,4 +1,4 @@
-import { type JSX, useState } from "react";
+import { type JSX, type ReactNode, useState } from "react";
 import { Button } from "../ui/button";
 import {
   Eye,
@@ -45,6 +45,35 @@ type EnhancedError = {
 type TestResult = {
   success: boolean;
   error?: EnhancedError;
+  model?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheCreationInputTokens?: number;
+  cacheReadInputTokens?: number;
+  latencyMs?: number;
+  content?: ResponseContent[];
+  rawResponse?: string;
+  streaming?: boolean;
+  streamingChunks?: StreamingChunksData;
+  requestHeaders?: Record<string, string>;
+};
+
+type ResponseContent = {
+  type: "text" | "thinking";
+  text?: string;
+  thinking?: string;
+};
+
+type StreamingChunksData = {
+  chunks: StreamingChunk[];
+  truncated?: boolean;
+};
+
+type StreamingChunk = {
+  index: number;
+  timestamp: number;
+  type: string;
+  data: unknown;
 };
 
 type NotConfigured = { notConfigured: true };
@@ -133,10 +162,37 @@ function TestStatus({ result }: { result: TestResult | NotConfigured | Testing }
     );
   }
   if (result.success) {
+    const tokenParts: ReactNode[] = [];
+    if (result.inputTokens !== undefined) {
+      tokenParts.push(<span key="in">{result.inputTokens} in</span>);
+    }
+    if (result.outputTokens !== undefined) {
+      tokenParts.push(<span key="out">{result.outputTokens} out</span>);
+    }
+    if (result.cacheCreationInputTokens !== undefined && result.cacheCreationInputTokens > 0) {
+      tokenParts.push(
+        <span key="cache-create" className="font-mono tabular-nums text-emerald-400">
+          +{result.cacheCreationInputTokens} cache
+        </span>,
+      );
+    }
+    if (result.cacheReadInputTokens !== undefined && result.cacheReadInputTokens > 0) {
+      tokenParts.push(
+        <span key="cache-read" className="font-mono tabular-nums text-purple-400">
+          ~{result.cacheReadInputTokens} cached
+        </span>,
+      );
+    }
+    const displayTokens: ReactNode[] = [];
+    for (let i = 0; i < tokenParts.length; i++) {
+      if (i > 0) displayTokens.push(", ");
+      displayTokens.push(tokenParts[i]);
+    }
     return (
       <div className="flex items-center gap-1 text-xs text-green-600 shrink-0">
         <CheckCircle className="size-3" />
         <span>Connected</span>
+        {tokenParts.length > 0 && <span className="text-muted-foreground">({displayTokens})</span>}
       </div>
     );
   }

package/src/components/providers/ProvidersPanel.tsx

@@ -28,6 +28,35 @@ type EnhancedError = {
 type TestResult = {
   success: boolean;
   error?: EnhancedError;
+  model?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheCreationInputTokens?: number;
+  cacheReadInputTokens?: number;
+  latencyMs?: number;
+  content?: ResponseContent[];
+  rawResponse?: string;
+  streaming?: boolean;
+  streamingChunks?: StreamingChunksData;
+  requestHeaders?: Record<string, string>;
+};
+
+type ResponseContent = {
+  type: "text" | "thinking";
+  text?: string;
+  thinking?: string;
+};
+
+type StreamingChunksData = {
+  chunks: StreamingChunk[];
+  truncated?: boolean;
+};
+
+type StreamingChunk = {
+  index: number;
+  timestamp: number;
+  type: string;
+  data: unknown;
 };
 
 type NotConfigured = { notConfigured: true };

package/src/proxy/formats/registry.ts

@@ -27,12 +27,8 @@ class FormatRegistryImpl {
   /** Get handler matching a request path */
   getByPath(path: string): FormatHandler | undefined {
     const messagesPath = path.split("?")[0] ?? "";
-    // DeepSeek /v1/messages is chat completions replay
-    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 undefined;
+    const format = this.pathMap.get(messagesPath);
+    return format === undefined ? undefined : this.handlers.get(format);
   }
 
   /** Detect format from request body content */

package/src/proxy/handler.ts

@@ -1,34 +1,34 @@
 import { createLog, emitLogUpdate, getNextLogId, type CapturedLog } from "./store";
 import { appendLogEntry, logger } from "./logger";
 import { writeChunks } from "./chunkStorage";
-import { extractModelFromBody, extractRequestMetadata, type RequestFormat } from "./schemas";
+import { extractRequestMetadata } from "./schemas";
 import { registry } from "./formats";
 import { findProviderByModel } from "./providers";
 import { getClientInfo } from "./socketTracker";
-import { formatForPath, formatRegistry, type FormatHandler } from "./formats";
+import { formatForPath, type FormatHandler } from "./formats";
 import {
-  DEFAULT_UPSTREAM,
-  DEFAULT_OPENAI_UPSTREAM,
   PROXY_IDENTITY,
   PRESERVE_HEADERS,
-  PATH_V1_CHAT_COMPLETIONS,
-  PATH_CHAT_COMPLETIONS,
   PATH_V1_MESSAGES,
   HEADER_CONTENT_TYPE,
   HEADER_USER_AGENT,
   HEADER_X_PROXY_IDENTITY,
-  HEADER_AUTHORIZATION,
-  HEADER_X_API_KEY,
   HEADER_CONTENT_ENCODING,
   HEADER_CONTENT_LENGTH,
-  HEADER_HOST,
-  AUTH_HEADER_X_API_KEY,
   CONTENT_TYPE_EVENT_STREAM,
   STATUS_FORBIDDEN,
   STATUS_BAD_GATEWAY,
 } from "./constants";
 import { getConfig } from "./config";
 import { stripClaudeCodeBillingHeader } from "./claudeCodeStrip";
+import {
+  buildUpstreamUrl,
+  describeApiRoute,
+  getProxyApiPath,
+  injectProviderAuth,
+  selectUpstreamBase,
+  setUpstreamHost,
+} from "./upstream";
 
 /**
  * Strips all custom/non-standard headers from the request and replaces with
@@ -58,15 +58,6 @@ function buildProxyHeaders(originalHeaders: Headers): {
   return { headers, rawHeaders };
 }
 
-function getHostFromUrl(urlStr: string): string {
-  try {
-    const url = new URL(urlStr);
-    return url.host;
-  } catch {
-    return "api.anthropic.com";
-  }
-}
-
 function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string, unknown> {
   return {
     timestamp: log.timestamp,
@@ -97,103 +88,22 @@ function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string
 
 type ParsedRequestPath = {
   apiPath: string;
-  messagesPath: string;
-  isChatCompletionsV1: boolean;
-  isChatCompletions: boolean;
   isMessages: boolean;
   normalizedPath: string;
 };
 
 function parseRequestPath(req: Request, url: URL): ParsedRequestPath {
-  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 route = describeApiRoute(getProxyApiPath(url));
   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;
+    req.method === "POST" && (route.endpointPath === PATH_V1_MESSAGES || route.isChatCompletions);
 
   return {
-    apiPath,
-    messagesPath,
-    isChatCompletionsV1,
-    isChatCompletions,
+    apiPath: route.apiPath,
     isMessages,
-    normalizedPath,
+    normalizedPath: route.normalizedPath,
   };
 }
 
-function buildUpstreamUrl(upstreamBase: string, normalizedPath: string): string {
-  // Remove trailing slash from upstreamBase to avoid double slashes
-  const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
-  // Handle case where upstreamBase already ends with /v1 and normalizedPath starts with /v1/
-  // to avoid double /v1/v1/ duplication
-  if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
-    return base + normalizedPath.slice(3); // Remove leading /v1 from path
-  }
-  return base + normalizedPath;
-}
-
-function selectUpstreamBase(
-  isChatCompletions: boolean,
-  matchedProviderConfig: ReturnType<typeof findProviderByModel>,
-): string {
-  let upstreamBase: string;
-
-  if (matchedProviderConfig) {
-    // Choose URL based on request format: ChatCompletions uses OpenAI URL, otherwise Anthropic URL
-    if (
-      isChatCompletions &&
-      matchedProviderConfig.openaiBaseUrl !== undefined &&
-      matchedProviderConfig.openaiBaseUrl !== ""
-    ) {
-      upstreamBase = matchedProviderConfig.openaiBaseUrl;
-    } else if (
-      !isChatCompletions &&
-      matchedProviderConfig.anthropicBaseUrl !== undefined &&
-      matchedProviderConfig.anthropicBaseUrl !== ""
-    ) {
-      upstreamBase = matchedProviderConfig.anthropicBaseUrl;
-    } else if (
-      matchedProviderConfig.baseUrl !== undefined &&
-      matchedProviderConfig.baseUrl !== ""
-    ) {
-      // Fallback to baseUrl for backward compatibility
-      upstreamBase = matchedProviderConfig.baseUrl;
-    } else {
-      // Fall back to defaults based on format
-      upstreamBase =
-        matchedProviderConfig.format === "openai" ? DEFAULT_OPENAI_UPSTREAM : DEFAULT_UPSTREAM;
-    }
-  } else {
-    // No provider config, use defaults
-    upstreamBase = isChatCompletions ? DEFAULT_OPENAI_UPSTREAM : DEFAULT_UPSTREAM;
-  }
-
-  return upstreamBase;
-}
-
-function injectAuthHeaders(
-  upstreamHeaders: Headers,
-  matchedProviderConfig: ReturnType<typeof findProviderByModel>,
-): void {
-  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: Response,
   responseBody: string,
@@ -339,14 +249,14 @@ export async function handleProxy(req: Request): Promise<Response> {
 
   // 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 route = describeApiRoute(parsed.apiPath);
+  const upstreamBase = selectUpstreamBase(route, matchedProviderConfig);
   const upstreamUrl = buildUpstreamUrl(upstreamBase, parsed.normalizedPath);
-  const upstreamHost = getHostFromUrl(upstreamBase);
   const startTime = Date.now();
 
   const { headers: upstreamHeaders, rawHeaders } = buildProxyHeaders(req.headers);
-  upstreamHeaders.set(HEADER_HOST, upstreamHost);
-  injectAuthHeaders(upstreamHeaders, matchedProviderConfig);
+  setUpstreamHost(upstreamHeaders, upstreamBase);
+  injectProviderAuth(upstreamHeaders, matchedProviderConfig);
 
   const provider = model !== null ? registry.findProvider(model) : null;
 
@@ -356,17 +266,13 @@ export async function handleProxy(req: Request): Promise<Response> {
     return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
   }
 
-  // Get the format handler based on the actual upstream URL being used.
-  // For Chat Completions, the upstream always returns OpenAI SSE format regardless
-  // of provider config (which may have format=anthropic for backward compat).
-  let formatHandler: FormatHandler | null;
-  if (parsed.isChatCompletions) {
-    formatHandler = formatRegistry.get("openai") ?? null;
-  } else if (matchedProviderConfig?.format) {
-    formatHandler = formatRegistry.get(matchedProviderConfig.format) ?? null;
-  } else {
-    formatHandler = formatForPath(parsed.apiPath);
-  }
+  // Pick the format handler from the request path. provider.format is only a
+  // hint used as a fallback when no anthropicBaseUrl/openaiBaseUrl is set, and
+  // does NOT describe what the upstream actually returns: a provider configured
+  // with format="openai" may still expose an Anthropic-compatible endpoint
+  // (e.g. MiniMax's /anthropic path), and the response shape always follows
+  // the URL path the client hit, not the provider.format label.
+  const formatHandler: FormatHandler | null = formatForPath(parsed.apiPath);
   if (formatHandler === null) {
     return new Response("Forbidden: unsupported format", { status: STATUS_FORBIDDEN });
   }

package/src/proxy/providers.ts

@@ -103,50 +103,22 @@ export const store = new Conf<ProvidersStore>({
 migrateFromLegacyConfLocation(store);
 
 /**
- * Migrates a single provider config to preserve both Anthropic and OpenAI URLs.
+ * Expands the old `{ format, baseUrl }` representation into the matching
+ * format-specific URL. Once either format-specific field exists, the record is
+ * already on the current schema and must be preserved exactly: an empty or
+ * missing counterpart means that protocol was intentionally not configured.
  */
 export function migrateProvider(p: ProviderConfig): ProviderConfig {
-  const currentAnthropicUrl = p.anthropicBaseUrl ?? "";
-  const currentOpenaiUrl = p.openaiBaseUrl ?? "";
-
-  // If already migrated (has at least one URL set), skip
-  // format may be undefined but if URL is set, it's already migrated
-  if (currentAnthropicUrl !== "" || currentOpenaiUrl !== "") {
+  if (p.anthropicBaseUrl !== undefined || p.openaiBaseUrl !== undefined) {
     return p;
   }
-
-  // Determine primary format based on which URL is set
-  let format: "anthropic" | "openai" | undefined;
-  let baseUrl: string | undefined;
-
-  if (currentAnthropicUrl !== "" && currentOpenaiUrl !== "") {
-    // Both URLs set - prefer anthropic as default, use baseUrl for backward compat
-    format = p.format ?? "anthropic";
-    baseUrl = p.baseUrl !== undefined && p.baseUrl !== "" ? p.baseUrl : currentAnthropicUrl;
-  } else if (currentOpenaiUrl !== "") {
-    format = "openai";
-    baseUrl = currentOpenaiUrl;
-  } else if (currentAnthropicUrl !== "") {
-    format = "anthropic";
-    baseUrl = currentAnthropicUrl;
-  } else if (p.format !== undefined && p.baseUrl !== undefined && p.baseUrl !== "") {
-    // Only baseUrl is set (legacy config) - migrate based on format
-    format = p.format;
-    baseUrl = p.baseUrl;
-    if (format === "openai") {
-      return { ...p, format, baseUrl, anthropicBaseUrl: "", openaiBaseUrl: p.baseUrl };
-    } else {
-      return { ...p, format, baseUrl, anthropicBaseUrl: p.baseUrl, openaiBaseUrl: "" };
-    }
+  if (p.format === undefined || p.baseUrl === undefined || p.baseUrl === "") {
+    return p;
   }
 
-  return {
-    ...p,
-    format,
-    baseUrl,
-    anthropicBaseUrl: currentAnthropicUrl,
-    openaiBaseUrl: currentOpenaiUrl,
-  };
+  return p.format === "openai"
+    ? { ...p, anthropicBaseUrl: "", openaiBaseUrl: p.baseUrl }
+    : { ...p, anthropicBaseUrl: p.baseUrl, openaiBaseUrl: "" };
 }
 
 /**
@@ -389,9 +361,11 @@ function normalizeModelName(name: string): string {
 }
 
 /**
- * Finds a provider by model name using two strategies:
+ * Finds a provider by model name using three strategies:
  * 1. Case-insensitive prefix match against "{provider.name}-" (e.g., "deepseek-" matches "deepseek-*")
  * 2. Case-insensitive match against provider.model field (with whitespace/hyphen normalization)
+ * 3. Fallback: concatenate provider name with provider's model and check if the request model matches
+ *    this concatenation (handles "MiniMax" + "M3" → "MiniMax-M3" pattern when case differs)
  */
 export function findProviderByModel(model: string): ProviderConfig | null {
   const providers = getProviders();
@@ -412,6 +386,15 @@ export function findProviderByModel(model: string): ProviderConfig | null {
     ) {
       return provider;
     }
+    // Strategy 3: fallback - concatenate provider name with model part and compare
+    // This handles cases like "MiniMax" + "M3" → "MiniMax-M3" when case differs
+    if (provider.model !== undefined && provider.model !== "") {
+      const modelPart = modelNormalized.replace(normalizeModelName(provider.name), "");
+      const concatenated = normalizeModelName(provider.name) + modelPart;
+      if (modelNormalized === concatenated) {
+        return provider;
+      }
+    }
   }
   return null;
 }

package/src/proxy/upstream.ts

@@ -0,0 +1,90 @@
+import type { ProviderConfig } from "./providers";
+import {
+  AUTH_HEADER_X_API_KEY,
+  DEFAULT_OPENAI_UPSTREAM,
+  DEFAULT_UPSTREAM,
+  HEADER_AUTHORIZATION,
+  HEADER_HOST,
+  HEADER_X_API_KEY,
+  PATH_CHAT_COMPLETIONS,
+  PATH_V1_CHAT_COMPLETIONS,
+} from "./constants";
+
+export type ApiRoute = {
+  apiPath: string;
+  endpointPath: string;
+  isChatCompletions: boolean;
+  normalizedPath: string;
+};
+
+/**
+ * Describes the protocol implied by the client-facing path.
+ *
+ * The path is the source of truth for request/response format. ProviderConfig.format
+ * is only a fallback for old provider records that do not have a format-specific URL.
+ */
+export function describeApiRoute(apiPath: string): ApiRoute {
+  const endpointPath = apiPath.split("?")[0] ?? "";
+  const isChatCompletions =
+    endpointPath === PATH_CHAT_COMPLETIONS || endpointPath === PATH_V1_CHAT_COMPLETIONS;
+  const normalizedPath =
+    isChatCompletions && !apiPath.startsWith("/v1/") ? `/v1${apiPath}` : apiPath;
+
+  return { apiPath, endpointPath, isChatCompletions, normalizedPath };
+}
+
+export function getProxyApiPath(url: URL): string {
+  return url.pathname.replace(/^\/proxy/, "") + url.search;
+}
+
+export function selectUpstreamBase(route: ApiRoute, provider: ProviderConfig | null): string {
+  if (provider === null) {
+    return route.isChatCompletions ? DEFAULT_OPENAI_UPSTREAM : DEFAULT_UPSTREAM;
+  }
+
+  const formatSpecificUrl = route.isChatCompletions
+    ? provider.openaiBaseUrl
+    : provider.anthropicBaseUrl;
+  if (formatSpecificUrl !== undefined && formatSpecificUrl !== "") {
+    return formatSpecificUrl;
+  }
+  if (provider.baseUrl !== undefined && provider.baseUrl !== "") {
+    return provider.baseUrl;
+  }
+
+  // Legacy records may only contain format. Keep this fallback for compatibility,
+  // but never use it to infer the response parser; that decision comes from the path.
+  return provider.format === "openai" ? DEFAULT_OPENAI_UPSTREAM : DEFAULT_UPSTREAM;
+}
+
+export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string): string {
+  const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
+
+  // Many OpenAI-compatible base URLs already include /v1. Avoid producing /v1/v1.
+  if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+    return base + normalizedPath.slice(3);
+  }
+  return base + normalizedPath;
+}
+
+export function setUpstreamHost(headers: Headers, upstreamBase: string): void {
+  try {
+    headers.set(HEADER_HOST, new URL(upstreamBase).host);
+  } catch {
+    // Invalid provider URLs are rejected by the UI. Retain the historical default
+    // for imported or manually edited config that bypassed that validation.
+    headers.set(HEADER_HOST, "api.anthropic.com");
+  }
+}
+
+export function injectProviderAuth(headers: Headers, provider: ProviderConfig | null): void {
+  if (provider === null) return;
+
+  const apiKey = provider.apiKey.replace(/^Bearer\s+/i, "").trim();
+  if (provider.authHeader === AUTH_HEADER_X_API_KEY) {
+    headers.set(HEADER_X_API_KEY, apiKey);
+    headers.delete(HEADER_AUTHORIZATION);
+    return;
+  }
+  headers.set(HEADER_AUTHORIZATION, `Bearer ${apiKey}`);
+}

package/src/routes/api/logs.$id.replay.ts

@@ -3,28 +3,24 @@ import { z } from "zod";
 import { getLogById } from "../../proxy/store";
 import { findProviderByModel } from "../../proxy/providers";
 import { registry } from "../../proxy/formats";
-import { formatForPath, type FormatHandler } from "../../proxy/formats";
+import { formatForPath } from "../../proxy/formats";
 import { extractModelFromBody } from "../../proxy/schemas";
 import {
-  DEFAULT_UPSTREAM,
-  DEFAULT_OPENAI_UPSTREAM,
   PROXY_IDENTITY,
   PRESERVE_HEADERS,
-  PATH_V1_CHAT_COMPLETIONS,
-  PATH_CHAT_COMPLETIONS,
-  PATH_V1_MESSAGES,
   HEADER_CONTENT_TYPE,
   HEADER_USER_AGENT,
   HEADER_X_PROXY_IDENTITY,
-  HEADER_AUTHORIZATION,
-  HEADER_X_API_KEY,
-  HEADER_CONTENT_ENCODING,
-  HEADER_CONTENT_LENGTH,
-  HEADER_HOST,
-  AUTH_HEADER_X_API_KEY,
+  CONTENT_TYPE_EVENT_STREAM,
   STATUS_FORBIDDEN,
-  STATUS_BAD_GATEWAY,
 } from "../../proxy/constants";
+import {
+  buildUpstreamUrl,
+  describeApiRoute,
+  injectProviderAuth,
+  selectUpstreamBase,
+  setUpstreamHost,
+} from "../../proxy/upstream";
 
 type ReplayRequest = {
   modifiedBody: string;
@@ -45,71 +41,6 @@ type ReplayResponse = {
   streaming?: boolean;
 };
 
-function getHostFromUrl(urlStr: string): string {
-  try {
-    const url = new URL(urlStr);
-    return url.host;
-  } catch {
-    return "api.anthropic.com";
-  }
-}
-
-function buildUpstreamUrl(upstreamBase: string, apiPath: string): string {
-  // Remove trailing slash from upstreamBase to avoid double slashes
-  const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
-  return base + apiPath;
-}
-
-function selectUpstreamBase(
-  isChatCompletions: boolean,
-  matchedProviderConfig: ReturnType<typeof findProviderByModel>,
-): string {
-  let upstreamBase: string;
-
-  if (matchedProviderConfig) {
-    if (
-      isChatCompletions &&
-      matchedProviderConfig.openaiBaseUrl !== undefined &&
-      matchedProviderConfig.openaiBaseUrl !== ""
-    ) {
-      upstreamBase = matchedProviderConfig.openaiBaseUrl;
-    } else if (
-      !isChatCompletions &&
-      matchedProviderConfig.anthropicBaseUrl !== undefined &&
-      matchedProviderConfig.anthropicBaseUrl !== ""
-    ) {
-      upstreamBase = matchedProviderConfig.anthropicBaseUrl;
-    } else if (
-      matchedProviderConfig.baseUrl !== undefined &&
-      matchedProviderConfig.baseUrl !== ""
-    ) {
-      upstreamBase = matchedProviderConfig.baseUrl;
-    } else {
-      upstreamBase =
-        matchedProviderConfig.format === "openai" ? DEFAULT_OPENAI_UPSTREAM : DEFAULT_UPSTREAM;
-    }
-  } else {
-    upstreamBase = isChatCompletions ? DEFAULT_OPENAI_UPSTREAM : DEFAULT_UPSTREAM;
-  }
-
-  return upstreamBase;
-}
-
-function injectAuthHeaders(
-  upstreamHeaders: Headers,
-  matchedProviderConfig: ReturnType<typeof findProviderByModel>,
-): void {
-  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}`);
-  }
-}
-
 export const Route = createFileRoute("/api/logs/$id/replay")({
   server: {
     handlers: {
@@ -159,22 +90,17 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
         }
 
         // Determine API path from original log
-        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 route = describeApiRoute(log.path);
 
         // Get format handler
-        const formatHandler = formatForPath(apiPath);
+        const formatHandler = formatForPath(route.apiPath);
         if (formatHandler === null) {
           return Response.json({ error: "Unsupported path" }, { status: STATUS_FORBIDDEN });
         }
 
         // Build upstream URL
-        const upstreamBase = selectUpstreamBase(isChatCompletions, matchedProviderConfig);
-        const upstreamUrl = buildUpstreamUrl(upstreamBase, normalizedPath);
-        const upstreamHost = getHostFromUrl(upstreamBase);
+        const upstreamBase = selectUpstreamBase(route, matchedProviderConfig);
+        const upstreamUrl = buildUpstreamUrl(upstreamBase, route.normalizedPath);
 
         // Build headers
         const headers = new Headers();
@@ -188,8 +114,8 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
             headers.set(name, value);
           }
         }
-        headers.set(HEADER_HOST, upstreamHost);
-        injectAuthHeaders(headers, matchedProviderConfig);
+        setUpstreamHost(headers, upstreamBase);
+        injectProviderAuth(headers, matchedProviderConfig);
 
         const startTime = Date.now();
 
@@ -210,7 +136,8 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
 
         const elapsedMs = Date.now() - startTime;
         const isStream =
-          upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes("text/event-stream") ?? false;
+          upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes(CONTENT_TYPE_EVENT_STREAM) ??
+          false;
 
         if (isStream) {
           // Accumulate streaming response