@tonyclaw/agent-inspector 2.0.0

package/src/proxy/handler.ts

@@ -0,0 +1,334 @@
+import { createLog, finalizeLogUpdate, getNextLogId, type CapturedLog } from "./store";
+import { appendLogEntry, logger } from "./logger";
+import { extractRequestMetadata } from "./schemas";
+import { registry } from "./formats";
+import { findProviderByModel } 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,
+  STATUS_FORBIDDEN,
+  STATUS_BAD_GATEWAY,
+} from "./constants";
+import { getConfig } from "./config";
+import { stripClaudeCodeBillingHeader } from "./claudeCodeStrip";
+import { stripOpenAIOrphanToolMessages } from "./openaiOrphanToolStrip";
+import { buildFileLogEntry, type FinalizeLogJob } from "./logFinalizer";
+import { enqueueFinalizeLogJob } from "./sessionRuntime";
+import {
+  buildUpstreamUrl,
+  describeApiRoute,
+  getProxyApiPath,
+  injectProviderAuth,
+  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): {
+  headers: Headers;
+  rawHeaders: Record<string, string>;
+} {
+  const rawHeaders: Record<string, string> = {};
+  const headers = new Headers();
+
+  originalHeaders.forEach((value, key) => {
+    rawHeaders[key.toLowerCase()] = value;
+  });
+
+  headers.set(HEADER_USER_AGENT, PROXY_IDENTITY);
+  headers.set(HEADER_X_PROXY_IDENTITY, PROXY_IDENTITY);
+
+  for (const name of PRESERVE_HEADERS) {
+    const value = originalHeaders.get(name);
+    if (value !== null) {
+      headers.set(name, value);
+    }
+  }
+
+  return { headers, rawHeaders };
+}
+
+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 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 handleStreamingResponse(
+  upstreamRes: Response,
+  req: Request,
+  startTime: number,
+  upstreamUrl: string,
+  log: CapturedLog,
+): Response {
+  log.streaming = true;
+  log.responseStatus = upstreamRes.status;
+
+  const chunks: string[] = [];
+  const decoder = new TextDecoder();
+
+  const transform = new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      controller.enqueue(chunk);
+      chunks.push(decoder.decode(chunk, { stream: true }));
+    },
+    flush() {
+      const full = chunks.join("");
+      const elapsedMs = Date.now() - startTime;
+
+      scheduleLogFinalization({
+        type: "streaming",
+        log,
+        upstreamUrl,
+        elapsedMs,
+        responseStatus: upstreamRes.status,
+        rawStream: full,
+      });
+    },
+  });
+
+  if (upstreamRes.body === null) {
+    return new Response("No response body", { status: STATUS_BAD_GATEWAY });
+  }
+
+  const loggedStream = upstreamRes.body.pipeThrough(transform);
+
+  req.signal?.addEventListener("abort", () => {
+    if (log.responseText === null) {
+      logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
+      const elapsedMs = Date.now() - startTime;
+      const full = chunks.join("");
+      const hasChunks = chunks.length > 0;
+
+      scheduleLogFinalization({
+        type: "stream-abort",
+        log,
+        upstreamUrl,
+        elapsedMs,
+        rawStream: full,
+        hasChunks,
+      });
+    }
+  });
+
+  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,
+  });
+}
+
+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();
+  }
+
+  // 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.
+  let bodyToForward = requestBody;
+  if (getConfig().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 protocol guard: OpenAI Chat Completions requires 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);
+  const upstreamBase = selectUpstreamBase(route, matchedProviderConfig);
+  const upstreamUrl = buildUpstreamUrl(upstreamBase, parsed.normalizedPath);
+  const startTime = Date.now();
+
+  const { headers: upstreamHeaders, rawHeaders } = buildProxyHeaders(req.headers);
+  setUpstreamHost(upstreamHeaders, upstreamBase);
+  injectProviderAuth(upstreamHeaders, matchedProviderConfig);
+
+  const provider = model !== null ? registry.findProvider(model) : null;
+
+  // 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 });
+  }
+
+  // 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 = 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> = {};
+  upstreamHeaders.forEach((value, key) => {
+    upstreamHeadersObj[key.toLowerCase()] = value;
+  });
+  const log = await createLog(
+    req.method,
+    parsed.apiPath,
+    requestBody,
+    req.headers,
+    clientInfo,
+    rawHeaders,
+    upstreamHeadersObj,
+    formatHandler.format,
+    model,
+    sessionId,
+    preAcquiredId,
+  );
+
+  let upstreamRes: Response;
+  try {
+    upstreamRes = await fetch(upstreamUrl, {
+      method: req.method,
+      headers: upstreamHeaders,
+      body: bodyToForward,
+      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" });
+      finalizeLogUpdate(log);
+      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) });
+    finalizeLogUpdate(log);
+    return new Response(`Proxy error: ${err}`, { status: STATUS_BAD_GATEWAY });
+  }
+
+  const isStream =
+    upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes(CONTENT_TYPE_EVENT_STREAM) ?? false;
+
+  if (!isStream) {
+    const responseBody = await upstreamRes.text();
+    return handleNonStreamingResponse(upstreamRes, responseBody, startTime, upstreamUrl, log);
+  }
+
+  return handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log);
+}

package/src/proxy/logFinalizer.ts

@@ -0,0 +1,305 @@
+import { Worker } from "node:worker_threads";
+import { writeChunks } from "./chunkStorage";
+import { formatForPath } from "./formats";
+import { appendLogEntry, logger } from "./logger";
+import type { CapturedLog } from "./schemas";
+import { getSessionProcess, isSessionProcessAvailable } from "./sessionProcess";
+import { finalizeLogUpdate } from "./store";
+
+type BaseFinalizeLogJob = {
+  log: CapturedLog;
+  upstreamUrl: string;
+  elapsedMs: number;
+};
+
+export type FinalizeNonStreamingLogJob = BaseFinalizeLogJob & {
+  type: "non-streaming";
+  responseStatus: number;
+  responseBody: string;
+};
+
+export type FinalizeStreamingLogJob = BaseFinalizeLogJob & {
+  type: "streaming";
+  responseStatus: number;
+  rawStream: string;
+};
+
+export type FinalizeStreamAbortLogJob = BaseFinalizeLogJob & {
+  type: "stream-abort";
+  rawStream: string;
+  hasChunks: boolean;
+};
+
+export type FinalizeLogJob =
+  | FinalizeNonStreamingLogJob
+  | FinalizeStreamingLogJob
+  | FinalizeStreamAbortLogJob;
+
+export type FinalizeLogResult = {
+  log: CapturedLog;
+  upstreamUrl: string;
+  error: string | null;
+};
+
+export function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string, unknown> {
+  return {
+    timestamp: log.timestamp,
+    id: log.id,
+    method: log.method,
+    path: log.path,
+    model: log.model,
+    sessionId: log.sessionId,
+    rawRequestBody: log.rawRequestBody,
+    responseStatus: log.responseStatus,
+    responseText: log.responseText,
+    inputTokens: log.inputTokens,
+    outputTokens: log.outputTokens,
+    cacheCreationInputTokens: log.cacheCreationInputTokens,
+    cacheReadInputTokens: log.cacheReadInputTokens,
+    elapsedMs: log.elapsedMs,
+    streaming: log.streaming,
+    userAgent: log.userAgent,
+    origin: log.origin,
+    upstreamUrl,
+    clientPort: log.clientPort,
+    clientPid: log.clientPid,
+    clientCwd: log.clientCwd,
+    clientProjectFolder: log.clientProjectFolder,
+    streamingChunks: log.streamingChunks,
+    streamingChunksPath: log.streamingChunksPath,
+    error: log.error,
+  };
+}
+
+function cloneLog(log: CapturedLog): CapturedLog {
+  return { ...log };
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+function persistStreamingChunks(log: CapturedLog): void {
+  if (log.streamingChunks !== undefined && log.streamingChunks.chunks.length > 0) {
+    const chunkPath = writeChunks(
+      log.id,
+      log.streamingChunks.chunks,
+      log.streamingChunks.truncated,
+    );
+    log.streamingChunksPath = chunkPath;
+  }
+}
+
+function finalizeWithError(
+  job: FinalizeLogJob,
+  log: CapturedLog,
+  fallbackStatus: number,
+  fallbackResponseText: string,
+  err: unknown,
+): FinalizeLogResult {
+  const message = errorMessage(err);
+  logger.error(`[logFinalizer] Failed to finalize log #${log.id}:`, message);
+  log.responseStatus = log.responseStatus ?? fallbackStatus;
+  log.responseText = log.responseText ?? fallbackResponseText;
+  log.elapsedMs = job.elapsedMs;
+  log.error = message;
+  return { log, upstreamUrl: job.upstreamUrl, error: message };
+}
+
+function finalizeNonStreaming(
+  job: FinalizeNonStreamingLogJob,
+  log: CapturedLog,
+): FinalizeLogResult {
+  const formatHandler = formatForPath(log.path);
+  if (formatHandler === null) {
+    return finalizeWithError(job, log, job.responseStatus, job.responseBody, "Unsupported format");
+  }
+
+  try {
+    const tokens = formatHandler.extractTokens(job.responseBody);
+
+    log.elapsedMs = job.elapsedMs;
+    log.responseStatus = job.responseStatus;
+    log.responseText = job.responseBody;
+    log.inputTokens = tokens.inputTokens;
+    log.outputTokens = tokens.outputTokens;
+    log.cacheCreationInputTokens = tokens.cacheCreationInputTokens;
+    log.cacheReadInputTokens = tokens.cacheReadInputTokens;
+
+    return { log, upstreamUrl: job.upstreamUrl, error: null };
+  } catch (err) {
+    return finalizeWithError(job, log, job.responseStatus, job.responseBody, err);
+  }
+}
+
+function finalizeStreaming(job: FinalizeStreamingLogJob, log: CapturedLog): FinalizeLogResult {
+  const formatHandler = formatForPath(log.path);
+  if (formatHandler === null) {
+    return finalizeWithError(job, log, job.responseStatus, job.rawStream, "Unsupported format");
+  }
+
+  try {
+    log.elapsedMs = job.elapsedMs;
+    log.responseStatus = job.responseStatus;
+    log.responseText = formatHandler.extractStream(
+      job.rawStream,
+      log,
+      log.model ?? undefined,
+      true,
+    );
+    persistStreamingChunks(log);
+
+    return { log, upstreamUrl: job.upstreamUrl, error: null };
+  } catch (err) {
+    return finalizeWithError(job, log, job.responseStatus, job.rawStream, err);
+  }
+}
+
+function finalizeStreamAbort(job: FinalizeStreamAbortLogJob, log: CapturedLog): FinalizeLogResult {
+  const formatHandler = formatForPath(log.path);
+  if (formatHandler === null && job.hasChunks) {
+    return finalizeWithError(job, log, 499, "Client aborted", "Unsupported format");
+  }
+
+  try {
+    log.elapsedMs = job.elapsedMs;
+    if (job.hasChunks && formatHandler !== null) {
+      log.responseText = formatHandler.extractStream(
+        job.rawStream,
+        log,
+        log.model ?? undefined,
+        true,
+      );
+      persistStreamingChunks(log);
+    } else {
+      log.responseText = "Client aborted";
+    }
+
+    return { log, upstreamUrl: job.upstreamUrl, error: "Client aborted" };
+  } catch (err) {
+    return finalizeWithError(job, log, 499, "Client aborted", err);
+  }
+}
+
+export function buildFinalizeLogResult(job: FinalizeLogJob): FinalizeLogResult {
+  const log = cloneLog(job.log);
+
+  switch (job.type) {
+    case "non-streaming":
+      return finalizeNonStreaming(job, log);
+    case "streaming":
+      return finalizeStreaming(job, log);
+    case "stream-abort":
+      return finalizeStreamAbort(job, log);
+  }
+}
+
+export function commitFinalizeLogResult(result: FinalizeLogResult): void {
+  appendLogEntry({ ...buildFileLogEntry(result.log, result.upstreamUrl), error: result.error });
+  finalizeLogUpdate(result.log);
+}
+
+// ── Worker pool ────────────────────────────────────────────────
+// buildFinalizeLogResult is the CPU-heavy step (token extraction,
+// SSE parsing, chunk persistence).  We offload it to a fixed pool
+// of Worker Threads so the main thread stays responsive even under
+// concurrent sessions.  commitFinalizeLogResult stays in-process
+// because it touches the in-memory cache, SSE emitter, and
+// append‑only log — all of which belong to the main thread.
+
+// ── Routing ─────────────────────────────────────────────────────
+// FINALIZER_RUNTIME selects the execution backend:
+//   "process" → per-session child process (max isolation)
+//   "worker"  → shared Worker Thread pool
+//   "inline"  → synchronous in-process (debug / fallback)
+// The default is "process" only when its worker entry exists. Production
+// bundles that do not emit the standalone worker entry fall back to "inline"
+// instead of repeatedly spawning a failing child process.
+// For backward compatibility, FINALIZER_USE_WORKER=0 forces "inline".
+
+const RUNTIME: "process" | "worker" | "inline" = (() => {
+  if (process.env["FINALIZER_USE_WORKER"] === "0") return "inline";
+  const mode = process.env["FINALIZER_RUNTIME"];
+  if (mode === "process") return "process";
+  if (mode === "worker") return "worker";
+  if (mode === "inline") return "inline";
+  return isSessionProcessAvailable() ? "process" : "inline";
+})();
+
+function executeBuildInSessionProcess(job: FinalizeLogJob): Promise<FinalizeLogResult> {
+  const sessionId = job.log.sessionId ?? "__unassigned__";
+  return getSessionProcess(sessionId)
+    .enqueue(job)
+    .catch((err: unknown) => {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(
+        `[logFinalizer] Session process failed for log #${job.log.id}, ` +
+          `falling back to in-process: ${message}`,
+      );
+      return buildFinalizeLogResult(job);
+    });
+}
+
+function resolveBuildPromise(job: FinalizeLogJob): Promise<FinalizeLogResult> {
+  switch (RUNTIME) {
+    case "process":
+      return executeBuildInSessionProcess(job);
+    case "worker":
+      return executeBuildInWorker(job);
+    case "inline":
+      return Promise.resolve(buildFinalizeLogResult(job));
+  }
+}
+
+const WORKER_COUNT = Math.max(1, Number(process.env["FINALIZER_WORKER_COUNT"]) || 4);
+let _workers: Worker[] | null = null;
+const _pending = new Map<string, (result: FinalizeLogResult) => void>();
+let _nextWorker = 0;
+let _jobSeq = 0;
+
+function getWorkers(): Worker[] {
+  if (_workers !== null) return _workers;
+  _workers = [];
+  for (let i = 0; i < WORKER_COUNT; i++) {
+    const w = new Worker(new URL("./logFinalizer.worker.ts", import.meta.url));
+    w.on("message", (msg: { id: string; result: FinalizeLogResult }) => {
+      const resolve = _pending.get(msg.id);
+      if (resolve !== undefined) {
+        _pending.delete(msg.id);
+        resolve(msg.result);
+      }
+    });
+    w.on("error", (err) => {
+      logger.error(
+        "[logFinalizer] Worker error:",
+        err instanceof Error ? err.message : String(err),
+      );
+    });
+    _workers.push(w);
+  }
+  return _workers;
+}
+
+export function executeBuildInWorker(job: FinalizeLogJob): Promise<FinalizeLogResult> {
+  return new Promise((resolve) => {
+    const list = getWorkers();
+    // getWorkers() always returns at least 1 worker; the array index is safe
+    const idx = _nextWorker % list.length;
+    _nextWorker++;
+    const w = list[idx];
+    if (w === undefined) return; // unreachable, satisfies type-checker
+    const id = String(++_jobSeq);
+    _pending.set(id, resolve);
+    w.postMessage({ id, job });
+  });
+}
+
+export function executeFinalizeLogJob(job: FinalizeLogJob): Promise<void> {
+  return resolveBuildPromise(job).then((result) => {
+    commitFinalizeLogResult(result);
+    if (result.error !== null && result.error !== "Client aborted") {
+      return Promise.reject(new Error(result.error));
+    }
+    return undefined;
+  });
+}

package/src/proxy/logFinalizer.worker.ts

@@ -0,0 +1,24 @@
+import { isMainThread, parentPort } from "node:worker_threads";
+import {
+  buildFinalizeLogResult,
+  type FinalizeLogJob,
+  type FinalizeLogResult,
+} from "./logFinalizer";
+
+if (!isMainThread && parentPort !== null) {
+  const port = parentPort;
+  port.on("message", (msg: { id: string; job: FinalizeLogJob }) => {
+    let result: FinalizeLogResult;
+    try {
+      result = buildFinalizeLogResult(msg.job);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result = {
+        log: msg.job.log,
+        upstreamUrl: msg.job.upstreamUrl,
+        error: message,
+      };
+    }
+    port.postMessage({ id: msg.id, result });
+  });
+}