@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/proxy/handler.ts

@@ -1,729 +0,0 @@
-import { Buffer } from "node:buffer";
-import { createLog, getNextLogId, persistFinalizedLogUpdate, type CapturedLog } from "./store";
-import { appendLogEntry, logger } from "./logger";
-import { extractRequestMetadata } from "./schemas";
-import { findProviderByModel, type ProviderConfig } from "./providers";
-import { getClientInfo } from "./socketTracker";
-import { formatForPath } from "./formats";
-import {
-  PROXY_IDENTITY,
-  PRESERVE_HEADERS,
-  PATH_V1_MESSAGES,
-  HEADER_CONTENT_TYPE,
-  HEADER_USER_AGENT,
-  HEADER_X_PROXY_IDENTITY,
-  HEADER_CONTENT_ENCODING,
-  HEADER_CONTENT_LENGTH,
-  CONTENT_TYPE_EVENT_STREAM,
-  SENSITIVE_HEADERS,
-  STATUS_FORBIDDEN,
-  STATUS_BAD_GATEWAY,
-  STATUS_PAYLOAD_TOO_LARGE,
-  MAX_REQUEST_BODY_BYTES,
-} from "./constants";
-import { getConfig } from "./config";
-import { safeFetch } from "../lib/safeFetch";
-
-const ALLOW_LOOPBACK = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
-const EMPTY_UPSTREAM_BODY_ERROR = "Upstream response did not include a body";
-const UPSTREAM_STREAM_ERROR = "Upstream stream terminated unexpectedly";
-const UPSTREAM_REQUEST_FAILED = "Proxy error: upstream request failed";
-const HEADER_ERROR_CODE = "x-agent-inspector-error-code";
-import { stripClaudeCodeBillingHeader } from "../lib/claudeCodeStrip";
-import { stripOpenAIOrphanToolMessages } from "./openaiOrphanToolStrip";
-import { maskApiKey } from "../lib/mask";
-import { buildFileLogEntry, type FinalizeLogJob } from "./logFinalizer";
-import { enqueueFinalizeLogJob } from "./sessionRuntime";
-import { RawStreamCapture } from "./rawStreamCapture";
-import {
-  acquireRuntimeRequest,
-  getRuntimeAdmissionState,
-  type RuntimeRequestLease,
-} from "./runtimeAdmission";
-import { DEFAULT_RUNTIME_BUDGET_POLICY, resourceLimitResponse } from "../lib/resourceLimits";
-import {
-  buildUpstreamUrl,
-  describeApiRoute,
-  getProxyApiPath,
-  injectProviderAuth,
-  providerSupportsApiRoute,
-  selectUpstreamBase,
-  setUpstreamHost,
-} from "./upstream";
-
-/**
- * Strips all custom/non-standard headers from the request and replaces with
- * unified proxy identity. Only preserves standard HTTP headers needed for API calls.
- */
-function buildProxyHeaders(
-  originalHeaders: Headers,
-  captureRawHeaders: boolean,
-): {
-  headers: Headers;
-  rawHeaders: Record<string, string> | undefined;
-} {
-  const rawHeaders: Record<string, string> | undefined = captureRawHeaders ? {} : undefined;
-  const headers = new Headers();
-
-  if (rawHeaders !== undefined) {
-    originalHeaders.forEach((value, key) => {
-      const lowerKey = key.toLowerCase();
-      rawHeaders[lowerKey] = SENSITIVE_HEADERS.has(lowerKey) ? maskApiKey(value) : 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 };
-}
-
-type ParsedRequestPath = {
-  apiPath: string;
-  isMessages: boolean;
-  isChatCompletions: boolean;
-  normalizedPath: string;
-};
-
-function parseRequestPath(req: Request, url: URL): ParsedRequestPath {
-  const route = describeApiRoute(getProxyApiPath(url));
-  const isPost = req.method === "POST";
-  const isChatCompletions = isPost && route.isChatCompletions;
-  const isMessages = isPost && (route.endpointPath === PATH_V1_MESSAGES || route.isChatCompletions);
-
-  return {
-    apiPath: route.apiPath,
-    isMessages,
-    isChatCompletions,
-    normalizedPath: route.normalizedPath,
-  };
-}
-
-function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
-function protocolLabel(route: ReturnType<typeof describeApiRoute>): string {
-  if (route.isResponses) return "openai-responses";
-  if (route.isChatCompletions) return "openai-chat-completions";
-  return "anthropic-messages";
-}
-
-function requiredProviderUrlField(route: ReturnType<typeof describeApiRoute>): string {
-  if (route.isResponses) return "openaiResponsesBaseUrl or openaiBaseUrl";
-  if (route.isChatCompletions) return "openaiBaseUrl";
-  return "anthropicBaseUrl";
-}
-
-function configuredProviderUrlFields(provider: ProviderConfig): string[] {
-  const fields: string[] = [];
-  if (provider.anthropicBaseUrl !== undefined && provider.anthropicBaseUrl.trim() !== "") {
-    fields.push("anthropicBaseUrl");
-  }
-  if (provider.openaiBaseUrl !== undefined && provider.openaiBaseUrl.trim() !== "") {
-    fields.push("openaiBaseUrl");
-  }
-  if (
-    provider.openaiResponsesBaseUrl !== undefined &&
-    provider.openaiResponsesBaseUrl.trim() !== ""
-  ) {
-    fields.push("openaiResponsesBaseUrl");
-  }
-  if (provider.baseUrl !== undefined && provider.baseUrl.trim() !== "") {
-    fields.push("baseUrl");
-  }
-  return fields;
-}
-
-type UnsupportedProviderRoute = {
-  code: "request-model-missing" | "provider-not-found" | "provider-route-mismatch";
-  detail: string;
-};
-
-function unsupportedProviderRoute(
-  model: string | null,
-  route: ReturnType<typeof describeApiRoute>,
-  provider: ProviderConfig | null,
-): UnsupportedProviderRoute {
-  if (model === null) {
-    const detail = `model could not be extracted; path=${route.normalizedPath}; protocol=${protocolLabel(route)}`;
-    logger.warn(`[handler] Unsupported provider route: code=request-model-missing; ${detail}`);
-    return { code: "request-model-missing", detail };
-  }
-
-  if (provider === null) {
-    const detail = `no Provider matched model=${model}; path=${route.normalizedPath}; protocol=${protocolLabel(route)}`;
-    logger.warn(`[handler] Unsupported provider route: code=provider-not-found; ${detail}`);
-    return { code: "provider-not-found", detail };
-  }
-
-  const configuredFields = configuredProviderUrlFields(provider);
-  const detail =
-    `Provider "${provider.name}" (${provider.id}) matched model=${model}, ` +
-    `but request path ${route.normalizedPath} requires ${protocolLabel(route)} via ` +
-    `${requiredProviderUrlField(route)}; configured URL fields=${
-      configuredFields.length > 0 ? configuredFields.join(",") : "none"
-    }`;
-  logger.warn(`[handler] Unsupported provider route: code=provider-route-mismatch; ${detail}`);
-  return { code: "provider-route-mismatch", detail };
-}
-
-type BodyReadResult = { ok: true; body: string | null } | { ok: false; reason: "too-large" };
-
-/**
- * Reads the request body as text, enforcing a maximum byte limit to prevent
- * memory exhaustion from oversized payloads. Returns the body string, or null
- * if the request has no body.
- */
-async function readBodyWithLimit(req: Request, limitBytes: number): Promise<BodyReadResult> {
-  if (req.body === null || req.method === "GET" || req.method === "HEAD") {
-    return { ok: true, body: null };
-  }
-
-  // Fast path: if Content-Length is present and exceeds the limit, reject
-  // without reading any bytes.
-  const contentLengthHeader = req.headers.get(HEADER_CONTENT_LENGTH);
-  if (contentLengthHeader !== null) {
-    const declared = Number.parseInt(contentLengthHeader, 10);
-    if (Number.isFinite(declared) && declared > limitBytes) {
-      return { ok: false, reason: "too-large" };
-    }
-  }
-
-  const reader = req.body.getReader();
-  const decoder = new TextDecoder();
-  const chunks: string[] = [];
-  let totalBytes = 0;
-
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      totalBytes += value.byteLength;
-      if (totalBytes > limitBytes) {
-        return { ok: false, reason: "too-large" };
-      }
-      chunks.push(decoder.decode(value, { stream: true }));
-    }
-    chunks.push(decoder.decode());
-    return { ok: true, body: chunks.join("") };
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-function scheduleLogFinalization(job: FinalizeLogJob): void {
-  void enqueueFinalizeLogJob(job).catch((err) => {
-    logger.error(
-      `[handler] Session finalization task failed for log #${job.log.id}:`,
-      errorMessage(err),
-    );
-  });
-}
-
-function handleNonStreamingResponse(
-  upstreamRes: Response,
-  responseBody: string,
-  startTime: number,
-  upstreamUrl: string,
-  log: CapturedLog,
-): Response {
-  const elapsedMs = Date.now() - startTime;
-
-  scheduleLogFinalization({
-    type: "non-streaming",
-    log,
-    upstreamUrl,
-    elapsedMs,
-    responseStatus: upstreamRes.status,
-    responseBody,
-  });
-
-  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 applyRawStreamCaptureStatus(log: CapturedLog, capture: RawStreamCapture): void {
-  const status = capture.status;
-  log.captureIncomplete = status.incomplete;
-  log.droppedChunks = status.droppedChunks;
-  log.droppedBytes = status.droppedBytes;
-  log.captureIncompleteReason = status.reason;
-}
-
-function applyUpstreamStreamError(log: CapturedLog): void {
-  log.captureIncomplete = true;
-  log.captureIncompleteReason = "upstream-stream-error";
-  log.error = UPSTREAM_STREAM_ERROR;
-}
-
-async function handleStreamingResponse(
-  upstreamRes: Response,
-  req: Request,
-  startTime: number,
-  upstreamUrl: string,
-  log: CapturedLog,
-  collectStreamingChunks: boolean,
-): Promise<Response> {
-  log.streaming = true;
-  log.responseStatus = upstreamRes.status;
-
-  if (upstreamRes.body === null) {
-    log.elapsedMs = Date.now() - startTime;
-    log.responseStatus = STATUS_BAD_GATEWAY;
-    log.responseText = EMPTY_UPSTREAM_BODY_ERROR;
-    log.captureIncomplete = true;
-    log.droppedChunks = 0;
-    log.droppedBytes = 0;
-    log.captureIncompleteReason = "upstream-stream-error";
-    log.error = EMPTY_UPSTREAM_BODY_ERROR;
-    appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: EMPTY_UPSTREAM_BODY_ERROR });
-    await persistFinalizedLogUpdate(log);
-    return new Response("No response body", { status: STATUS_BAD_GATEWAY });
-  }
-
-  const capture = new RawStreamCapture();
-  const decoder = new TextDecoder();
-  let finalizationScheduled = false;
-  let firstChunkMs: number | null = null;
-  let pendingDecoderBytes = 0;
-  let downstreamCancelled = false;
-
-  const submitDecodedText = (text: string, flush: boolean = false): void => {
-    const observedBytes = flush
-      ? pendingDecoderBytes
-      : Math.min(pendingDecoderBytes, Buffer.byteLength(text, "utf-8"));
-    pendingDecoderBytes -= observedBytes;
-    if (text === "" && observedBytes === 0) return;
-    capture.tryAppend(text, observedBytes);
-    applyRawStreamCaptureStatus(log, capture);
-  };
-
-  const scheduleStreamingFinalization = (
-    type: "streaming" | "stream-abort",
-    upstreamStreamFailed: boolean = false,
-  ): void => {
-    if (finalizationScheduled) return;
-    finalizationScheduled = true;
-
-    if (pendingDecoderBytes > 0) {
-      capture.recordDroppedObservation("pipeline-closed", pendingDecoderBytes);
-      pendingDecoderBytes = 0;
-    }
-
-    const totalStreamMs = Date.now() - startTime;
-    const elapsedMs = totalStreamMs;
-    void capture
-      .finalize()
-      .then((rawStream) => {
-        applyRawStreamCaptureStatus(log, capture);
-        if (upstreamStreamFailed) applyUpstreamStreamError(log);
-        switch (type) {
-          case "streaming":
-            scheduleLogFinalization({
-              type: "streaming",
-              log,
-              upstreamUrl,
-              elapsedMs,
-              responseStatus: upstreamRes.status,
-              rawStream,
-              collectStreamingChunks,
-              firstChunkMs,
-              totalStreamMs,
-              terminalError: upstreamStreamFailed ? UPSTREAM_STREAM_ERROR : null,
-            });
-            return;
-          case "stream-abort":
-            scheduleLogFinalization({
-              type: "stream-abort",
-              log,
-              upstreamUrl,
-              elapsedMs,
-              rawStream,
-              hasChunks: capture.hasChunks,
-              collectStreamingChunks,
-              firstChunkMs,
-              totalStreamMs,
-            });
-            return;
-        }
-      })
-      .catch((error: unknown) => {
-        const message = error instanceof Error ? error.message : String(error);
-        applyRawStreamCaptureStatus(log, capture);
-        if (upstreamStreamFailed) applyUpstreamStreamError(log);
-        log.captureIncomplete = true;
-        log.captureIncompleteReason ??= "finalize-failed";
-        logger.error(
-          `[handler] Raw stream finalization failed for log #${String(log.id)}:`,
-          message,
-        );
-        scheduleLogFinalization({
-          type: "stream-abort",
-          log,
-          upstreamUrl,
-          elapsedMs,
-          rawStream: { type: "memory", rawStream: "" },
-          hasChunks: capture.hasChunks,
-          collectStreamingChunks,
-          firstChunkMs,
-          totalStreamMs,
-        });
-      });
-  };
-
-  const transform = new TransformStream<Uint8Array, Uint8Array>({
-    transform(chunk, controller) {
-      if (firstChunkMs === null) firstChunkMs = Date.now() - startTime;
-      controller.enqueue(chunk);
-      pendingDecoderBytes += chunk.byteLength;
-      submitDecodedText(decoder.decode(chunk, { stream: true }));
-    },
-    flush() {
-      submitDecodedText(decoder.decode(), true);
-      scheduleStreamingFinalization("streaming");
-    },
-  });
-
-  // pipeTo returns a promise that rejects when either side errors. Without
-  // this catch, an upstream connection drop skips flush() and leaves the log
-  // permanently un-finalized with a leaked temp file.
-  void upstreamRes.body.pipeTo(transform.writable).catch(() => {
-    if (downstreamCancelled || req.signal?.aborted === true) {
-      scheduleStreamingFinalization("stream-abort");
-      return;
-    }
-    scheduleStreamingFinalization("streaming", true);
-  });
-  const transformedReader = transform.readable.getReader();
-  const loggedStream = new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      try {
-        const next = await transformedReader.read();
-        if (next.done) {
-          controller.close();
-          return;
-        }
-        controller.enqueue(next.value);
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-    async cancel(reason) {
-      downstreamCancelled = true;
-      scheduleStreamingFinalization("stream-abort");
-      await transformedReader.cancel(reason);
-    },
-  });
-
-  if (req.signal === undefined) {
-    logger.warn("[handler] req.signal is undefined; abort detection disabled for this request");
-  } else {
-    req.signal.addEventListener("abort", () => {
-      if (log.responseText === null) {
-        logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
-        scheduleStreamingFinalization("stream-abort");
-      }
-    });
-  }
-
-  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 handleAdmittedProxy(req: Request): Promise<Response> {
-  const url = new URL(req.url);
-  const parsed = parseRequestPath(req, url);
-
-  // Read body with a size limit to prevent memory exhaustion from oversized
-  // payloads. The limit is generous (50 MB) — legitimate LLM API requests are
-  // well under this, but a malicious client could send a multi-GB body to OOM
-  // the proxy.
-  const bodyRead = await readBodyWithLimit(req, MAX_REQUEST_BODY_BYTES);
-  if (!bodyRead.ok) {
-    logger.warn(`[handler] Rejected oversized request body: ${req.method} ${parsed.apiPath}`);
-    return new Response("Request body too large", { status: STATUS_PAYLOAD_TOO_LARGE });
-  }
-  const requestBody = bodyRead.body;
-
-  // Opt-in: strip Claude Code's synthetic billing-header text block from the
-  // system prompt. Only runs for Anthropic-format requests (those whose path
-  // resolves to /v1/messages). The flag is read once per request from the
-  // runtime config, so a PATCH to /api/config takes effect on the next
-  // request without a restart.
-  //
-  // Important: the original `requestBody` must be preserved so the log stores
-  // the unmodified request (the "Raw Request" tab needs the true bytes the
-  // client sent). The rewritten body is only used for the upstream fetch.
-  const config = getConfig();
-  let bodyToForward = requestBody;
-  if (config.stripClaudeCodeBillingHeader && requestBody !== null && parsed.isMessages) {
-    const stripped = stripClaudeCodeBillingHeader(requestBody);
-    if (stripped.removed > 0) {
-      logger.info(
-        `[handler] Stripped ${stripped.removed} Claude Code billing-header block(s) from system prompt`,
-      );
-      bodyToForward = stripped.body;
-    }
-  }
-
-  // Always-on OpenAI Chat Completions format guard: every
-  // `role: "tool"` message to reference a `tool_call_id` present in a
-  // preceding assistant message's `tool_calls`. Buggy clients sometimes
-  // record a tool result without the matching assistant tool_call, which
-  // makes the upstream reject the request with a 400 ("tool result's tool
-  // id(call_xxx) not found"). Drop the orphan messages so the proxy can
-  // forward a valid request; the original body is still kept in the log.
-  if (bodyToForward !== null && parsed.isChatCompletions) {
-    const stripped = stripOpenAIOrphanToolMessages(bodyToForward);
-    if (stripped.removed > 0) {
-      logger.warn(
-        `[handler] Dropped ${stripped.removed} orphan OpenAI tool message(s) with tool_call_id(s) ${JSON.stringify(stripped.orphanIds)} — the client sent a tool result with no matching assistant.tool_calls`,
-      );
-      bodyToForward = stripped.body;
-    }
-  }
-
-  // Parse the request body exactly once. The handler needs the model for
-  // provider routing and the session id for the log; `createLog` would
-  // otherwise re-parse the same body to extract the same fields.
-  const { model, sessionId } = extractRequestMetadata(requestBody, req.headers);
-
-  // Find provider config using already-extracted model (not calling extractModelFromBody again)
-  const matchedProviderConfig = model !== null ? findProviderByModel(model) : null;
-  const route = describeApiRoute(parsed.apiPath);
-
-  // Model matching is necessary but not sufficient: the Provider must explicitly expose the
-  // protocol selected by the request path. This guard stays before log creation and fetch so a
-  // protocol mismatch has the same zero-side-effect contract as an unconfigured model.
-  if (
-    model === null ||
-    matchedProviderConfig === null ||
-    !providerSupportsApiRoute(route, matchedProviderConfig)
-  ) {
-    const unsupported = unsupportedProviderRoute(model, route, matchedProviderConfig);
-    return new Response("Forbidden: unsupported provider", {
-      status: STATUS_FORBIDDEN,
-      headers: {
-        [HEADER_ERROR_CODE]: unsupported.code,
-      },
-    });
-  }
-
-  const upstreamBase = selectUpstreamBase(route, matchedProviderConfig);
-  const upstreamUrl = buildUpstreamUrl(upstreamBase, parsed.normalizedPath);
-
-  const startTime = Date.now();
-
-  const captureFullDetails = config.captureMode === "full";
-  const { headers: upstreamHeaders, rawHeaders } = buildProxyHeaders(
-    req.headers,
-    captureFullDetails,
-  );
-  setUpstreamHost(upstreamHeaders, upstreamBase);
-  injectProviderAuth(upstreamHeaders, matchedProviderConfig);
-
-  // Pick the format handler from the request path. ProviderConfig.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 = formatForPath(parsed.apiPath);
-  if (formatHandler === null) {
-    return new Response("Forbidden: unsupported format", { status: STATUS_FORBIDDEN });
-  }
-
-  // Acquire client info and the next log id in parallel. On Windows
-  // `getClientInfo` shells out to PowerShell and is the single slowest
-  // thing on the hot path; serializing it before `createLog` paid the
-  // full PowerShell round-trip on top of everything else before
-  // `fetch` is even issued.
-  const [clientInfo, preAcquiredId] = await Promise.all([getClientInfo(req), getNextLogId()]);
-  const upstreamHeadersObj: Record<string, string> | undefined = captureFullDetails
-    ? {}
-    : undefined;
-  if (upstreamHeadersObj !== undefined) {
-    upstreamHeaders.forEach((value, key) => {
-      const lowerKey = key.toLowerCase();
-      upstreamHeadersObj[lowerKey] = SENSITIVE_HEADERS.has(lowerKey) ? maskApiKey(value) : value;
-    });
-  }
-  const log = await createLog(
-    req.method,
-    parsed.apiPath,
-    requestBody,
-    req.headers,
-    clientInfo,
-    rawHeaders,
-    upstreamHeadersObj,
-    formatHandler.format,
-    model,
-    sessionId,
-    preAcquiredId,
-  );
-
-  let upstreamRes: Response;
-  try {
-    const fetchResult = await safeFetch(
-      upstreamUrl,
-      {
-        method: req.method,
-        headers: upstreamHeaders,
-        body: bodyToForward,
-        signal: req.signal,
-      },
-      {
-        allowLoopback: ALLOW_LOOPBACK,
-        deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.fetchDeadlineMs,
-        responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.fetchResponseBytes,
-      },
-    );
-    if (!fetchResult.ok) {
-      const status =
-        fetchResult.kind === "network-policy"
-          ? STATUS_FORBIDDEN
-          : fetchResult.kind === "resource-limit"
-            ? STATUS_PAYLOAD_TOO_LARGE
-            : STATUS_BAD_GATEWAY;
-      logger.warn(`[handler] Safe fetch blocked ${upstreamUrl}: ${fetchResult.reason}`);
-      log.elapsedMs = Date.now() - startTime;
-      log.responseStatus = status;
-      log.responseText = fetchResult.reason;
-      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: fetchResult.reason });
-      await persistFinalizedLogUpdate(log);
-      return new Response(
-        fetchResult.kind === "network-policy"
-          ? "Forbidden: upstream URL is not permitted"
-          : fetchResult.kind === "resource-limit"
-            ? "Proxy error: upstream response exceeded configured limits"
-            : fetchResult.kind === "timeout"
-              ? "Proxy error: upstream request timed out"
-              : "Proxy error: upstream redirects are not permitted",
-        { status },
-      );
-    }
-    upstreamRes = fetchResult.response;
-  } 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" });
-      await persistFinalizedLogUpdate(log);
-      return new Response("Client aborted", { status: 499 });
-    }
-    const upstreamError = errorMessage(err);
-    logger.error(`[handler] Proxy error: ${req.method} ${parsed.apiPath}`, upstreamError);
-    log.responseStatus = STATUS_BAD_GATEWAY;
-    log.responseText = upstreamError;
-    log.error = upstreamError;
-    appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: upstreamError });
-    await persistFinalizedLogUpdate(log);
-    return new Response(UPSTREAM_REQUEST_FAILED, { 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, upstreamUrl, log);
-  }
-
-  return handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log, captureFullDetails);
-}
-
-function responseWithRuntimeLease(response: Response, lease: RuntimeRequestLease): Response {
-  if (response.body === null) {
-    lease.release();
-    return response;
-  }
-
-  const reader = response.body.getReader();
-  let released = false;
-  const release = (): void => {
-    if (released) return;
-    released = true;
-    lease.release();
-  };
-  const trackedBody = new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      try {
-        const chunk = await reader.read();
-        if (chunk.done) {
-          controller.close();
-          release();
-          return;
-        }
-        controller.enqueue(chunk.value);
-      } catch (error) {
-        controller.error(error);
-        release();
-      }
-    },
-    async cancel(reason) {
-      try {
-        await reader.cancel(reason);
-      } finally {
-        release();
-      }
-    },
-  });
-
-  return new Response(trackedBody, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-  });
-}
-
-export async function handleProxy(req: Request): Promise<Response> {
-  const lease = acquireRuntimeRequest();
-  if (lease === null) {
-    const admission = getRuntimeAdmissionState();
-    if (admission.acceptingRequests) {
-      return resourceLimitResponse({
-        error: `Proxy request capacity reached. At most ${String(admission.capacity)} active requests are allowed; retry after a response completes.`,
-        code: "proxy-capacity-exceeded",
-        status: 503,
-        resource: "proxy-requests",
-        limit: admission.capacity,
-        retryable: true,
-        retryAfterSeconds: 1,
-      });
-    }
-    return Response.json(
-      { error: "Agent Inspector is shutting down" },
-      { status: 503, headers: { "cache-control": "no-store", "retry-after": "5" } },
-    );
-  }
-
-  try {
-    return responseWithRuntimeLease(await handleAdmittedProxy(req), lease);
-  } catch (error) {
-    lease.release();
-    return await Promise.reject(error);
-  }
-}