@neutrome/open-ai-router 0.4.1 → 0.5.0

package/.dev.vars.example

@@ -0,0 +1,2 @@
+# Required by the bundled OpenRouter provider in src/worker.ts.
+OPENROUTER_API_KEY=replace-with-your-openrouter-api-key

package/README.md

@@ -5,7 +5,11 @@ Deployable router app and reusable router/runtime library built on
 executor/tool contracts.
 
 ```ts
-import { createApp, createRouterRuntime, type RouterConfig } from "@neutrome/open-ai-router";
+import {
+  createRouterApp,
+  createRouterRuntime,
+  type RouterConfig,
+} from "@neutrome/open-ai-router";
 ```
 
 Primary runtime model:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neutrome/open-ai-router",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -8,16 +8,17 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "hono": "^4.12.18",
-    "@neutrome/lil-engine": "0.2.1",
-    "@neutrome/lilsdk-ts": "0.2.4"
+    "@neutrome/lil-engine": "0.3.0",
+    "@neutrome/lilsdk-ts": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
     "typescript": "^6.0.3",
     "vitest": "^4.1.6",
-    "wrangler": "^4.91.0"
+    "wrangler": "4.103.0"
   },
   "scripts": {
+    "generate": "pnpm run cf-typegen",
     "cf-typegen": "wrangler types",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit",

package/src/admission/access.ts

@@ -11,4 +11,3 @@ export function canAccessPrincipalModel(
   const namespace = modelId.split("/")[0] ?? "";
   return principal.allowedNamespaces?.includes(namespace) ?? false;
 }
-

package/src/admission/types.ts

@@ -11,4 +11,3 @@ export type RuntimeAuthenticator = {
     env: Record<string, unknown>,
   ): Promise<AuthPrincipal | null>;
 };
-

package/src/app/factory.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import type { ExecutionTrace } from "../observer.ts";
+import type { ExecutionSummary } from "../telemetry.ts";
 import type { RouterConfig } from "../router/index.ts";
 import { createRouterApp } from "./factory.ts";
 
@@ -8,7 +8,7 @@ const encoder = new TextEncoder();
 const config: RouterConfig = {
   providers: {
     openrouter: {
-      api_base_url: "https://openrouter.ai/api/v1",
+      apiBaseUrl: "https://openrouter.ai/api/v1",
       style: "chat-completions",
       exports: ["*"],
     },
@@ -26,7 +26,7 @@ const config: RouterConfig = {
 describe("createRouterApp trace finalization", () => {
   it("keeps non-stream trace hooks alive with waitUntil", async () => {
     const waited: Promise<unknown>[] = [];
-    const onTrace = vi.fn(async (_trace: ExecutionTrace) => {});
+    const onExecutionSummary = vi.fn(async (_summary: ExecutionSummary) => {});
     const app = createRouterApp({
       config,
       executorImplementations: {},
@@ -35,22 +35,24 @@ describe("createRouterApp trace finalization", () => {
           return principal();
         },
       },
-      hooks: { onTrace },
-      fetchImpl: vi.fn(async () =>
-        new Response(
-          JSON.stringify({
-            id: "resp_1",
-            model: "gpt-4o",
-            choices: [
-              {
-                index: 0,
-                message: { role: "assistant", content: "hello" },
-                finish_reason: "stop",
-              },
-            ],
-          }),
-          { headers: { "content-type": "application/json; charset=utf-8" } },
-        )),
+      hooks: { onExecutionSummary },
+      fetchImpl: vi.fn(
+        async () =>
+          new Response(
+            JSON.stringify({
+              id: "resp_1",
+              model: "gpt-4o",
+              choices: [
+                {
+                  index: 0,
+                  message: { role: "assistant", content: "hello" },
+                  finish_reason: "stop",
+                },
+              ],
+            }),
+            { headers: { "content-type": "application/json; charset=utf-8" } },
+          ),
+      ),
     });
 
     const response = await app.fetch(
@@ -69,12 +71,12 @@ describe("createRouterApp trace finalization", () => {
     expect(response.status).toBe(200);
     expect(waited).toHaveLength(1);
     await waited[0];
-    expect(onTrace).toHaveBeenCalledTimes(1);
+    expect(onExecutionSummary).toHaveBeenCalledTimes(1);
   });
 
   it("keeps stream trace hooks alive until the stream closes", async () => {
     const waited: Promise<unknown>[] = [];
-    const onTrace = vi.fn(async (_trace: ExecutionTrace) => {});
+    const onExecutionSummary = vi.fn(async (_summary: ExecutionSummary) => {});
     const app = createRouterApp({
       config,
       executorImplementations: {},
@@ -83,7 +85,7 @@ describe("createRouterApp trace finalization", () => {
           return principal();
         },
       },
-      hooks: { onTrace },
+      hooks: { onExecutionSummary },
       fetchImpl: vi.fn(async () => {
         const stream = new ReadableStream<Uint8Array>({
           start(controller) {
@@ -92,7 +94,9 @@ describe("createRouterApp trace finalization", () => {
                 `data: ${JSON.stringify({
                   id: "chunk_1",
                   model: "gpt-4o",
-                  choices: [{ index: 0, delta: { role: "assistant", content: "Hi" } }],
+                  choices: [
+                    { index: 0, delta: { role: "assistant", content: "Hi" } },
+                  ],
                 })}\n\n`,
               ),
             );
@@ -130,23 +134,25 @@ describe("createRouterApp trace finalization", () => {
       createExecutionContext(waited) as never,
     );
 
-    expect(response.headers.get("content-type")).toBe("text/event-stream; charset=utf-8");
+    expect(response.headers.get("content-type")).toBe(
+      "text/event-stream; charset=utf-8",
+    );
     expect(waited).toHaveLength(0);
 
     await response.text();
 
     expect(waited).toHaveLength(1);
     await waited[0];
-    expect(onTrace).toHaveBeenCalledTimes(1);
-    const rawTrace = onTrace.mock.calls[0]?.[0].rawTrace ?? "";
-    expect(rawTrace).toContain('"event":"admission.authenticate"');
-    expect(rawTrace).toContain('"event":"upstream_auth.collect_incoming"');
-    expect(rawTrace).toContain('"event":"upstream_auth.resolve_target"');
-    expect(rawTrace).toContain('"event":"provider.stream_first_byte"');
-    expect(rawTrace).toContain('"event":"response.stream_first_chunk"');
-    expect(rawTrace).toContain('"event":"provider.stream_finished"');
-    expect(rawTrace).toContain('"startedAt"');
-    expect(rawTrace).toContain('"finishedAt"');
+    expect(onExecutionSummary).toHaveBeenCalledTimes(1);
+    const events = onExecutionSummary.mock.calls[0]?.[0].spans.map(
+      (span) => span.event,
+    );
+    expect(events).toContain("admission.authenticate");
+    expect(events).toContain("upstream_auth.collect_incoming");
+    expect(events).toContain("upstream_auth.resolve_target");
+    expect(events).toContain("provider.stream_first_byte");
+    expect(events).toContain("response.stream_first_chunk");
+    expect(events).toContain("provider.stream_started");
   });
 });
 

package/src/app/factory.ts

@@ -1,9 +1,13 @@
 import { Hono, type Context } from "hono";
-import type { Executor, ProgramTransform } from "@neutrome/lilsdk-ts";
-import { getModel, setStreaming, type Program, type ProviderStyle } from "@neutrome/lil-engine";
+import {
+  getModel,
+  setStreaming,
+  type Program,
+  type ProviderStyle,
+} from "@neutrome/lil-engine";
 import { cors } from "./cors.ts";
 import { healthHandler } from "./health.ts";
-import { createTraceCollector, type ExecutionTrace } from "../observer.ts";
+import { createRouterTelemetry } from "../telemetry.ts";
 import { canAccessPrincipalModel } from "../admission/access.ts";
 import {
   createRouterRuntime,
@@ -12,47 +16,32 @@ import {
   handleGoogleGenAI,
   parseRequestProgram,
   handleResponses,
-  listConfiguredModels,
 } from "../router/index.ts";
-import type { AuthPrincipal, RuntimeAuthenticator } from "../admission/types.ts";
 import type { RequestContext } from "../upstream-auth/types.ts";
-import type { RouterConfig } from "../router/config.ts";
-import type { RemoteMcpClientFactory } from "../router/mcp.ts";
 import type { ExecutionRuntimeOptions } from "../router/execution-types.ts";
-import { observeTimingEvent } from "../timing.ts";
-
-export type RouterAppAuth = RuntimeAuthenticator;
-
-export type RouterAppHooks = {
-  beforeRequest?(ctx: {
-    request: Request;
-    model: string | null;
-    principal: AuthPrincipal;
-    env: Record<string, unknown>;
-  }): Promise<Response | void>;
-  onTrace?(trace: ExecutionTrace, env: Record<string, unknown>): void | Promise<void>;
-};
+import { observeTimedExecution } from "../router/execution-events.ts";
+import { createOpenAiErrorResponse } from "../router/errors.ts";
+import {
+  parseGoogleGenAIRoute,
+  rewriteGoogleGenAIRequest,
+} from "./google-genai-route.ts";
+import {
+  finalizeWhenStreamCloses,
+  isEventStreamResponse,
+  runBackgroundTask,
+} from "./response-lifecycle.ts";
+import { createModelListingHandler } from "./model-listing.ts";
+import { honoEnv, unauthorizedResponse } from "./http-utils.ts";
+import type { RouterAppOptions } from "./types.ts";
 
-export type RouterAppOptions = {
-  config: RouterConfig;
-  executorImplementations: Readonly<Record<string, Executor>>;
-  transforms?: Readonly<Record<string, ProgramTransform>>;
-  auth: RouterAppAuth;
-  hooks?: RouterAppHooks;
-  fetchImpl?: typeof fetch;
-  knownSuffixes?: string[];
-  observe?: ExecutionRuntimeOptions["observe"];
-  requestIdFactory?: ExecutionRuntimeOptions["requestIdFactory"];
-  executionIdFactory?: ExecutionRuntimeOptions["executionIdFactory"];
-  upstreamTimeoutMs?: number;
-  remoteMcpClientFactory?: RemoteMcpClientFactory;
-};
+type ProtocolHandler = (
+  options: Parameters<typeof handleChatCompletions>[0],
+) => Promise<Response>;
 
 export function createRouterApp(options: RouterAppOptions) {
   const runtime = createRouterRuntime({
     config: options.config,
     ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
-    ...(options.knownSuffixes ? { knownSuffixes: options.knownSuffixes } : {}),
   });
 
   const app = new Hono();
@@ -61,30 +50,34 @@ export function createRouterApp(options: RouterAppOptions) {
   app.get("/health", healthHandler());
 
   app.get("/v1/models", async (c) => {
-    const env = honoEnv(c);
-    const principal = await options.auth.authenticate(c.req.raw, env);
-    if (!principal) return unauthorized();
-
-    const models = listConfiguredModels(runtime)
-      .filter((id) => canAccessPrincipalModel(principal, id))
-      .map((id) => ({
-        id,
-        object: "model" as const,
-        created: 0,
-        owned_by: id.split("/")[0] || "unknown",
-      }));
-    return c.json({ object: "list", data: models });
+    const response = await createModelListingHandler({
+      runtime,
+      auth: options.auth,
+    })(c.req.raw, honoEnv(c));
+    return response instanceof Response ? response : c.json(response);
   });
 
-  app.post("/v1/chat/completions", (c) => runAuthorized(c, c.req.raw, "chat-completions", handleChatCompletions));
-  app.post("/v1/responses", (c) => runAuthorized(c, c.req.raw, "responses", handleResponses));
-  app.post("/v1/messages", (c) => runAuthorized(c, c.req.raw, "anthropic-messages", handleAnthropicMessages));
+  app.post("/v1/chat/completions", (c) =>
+    runAuthorized(c, c.req.raw, "chat-completions", handleChatCompletions),
+  );
+  app.post("/v1/responses", (c) =>
+    runAuthorized(c, c.req.raw, "responses", handleResponses),
+  );
+  app.post("/v1/messages", (c) =>
+    runAuthorized(c, c.req.raw, "anthropic-messages", handleAnthropicMessages),
+  );
 
   app.post("/v1/models/*", async (c) => {
     const route = parseGoogleGenAIRoute(c.req.raw);
     if (!route) return c.text("Not Found", 404);
     const request = await rewriteGoogleGenAIRequest(c.req.raw, route);
-    return runAuthorized(c, request, "google-genai", handleGoogleGenAI, route.stream);
+    return runAuthorized(
+      c,
+      request,
+      "google-genai",
+      handleGoogleGenAI,
+      route.stream,
+    );
   });
 
   app.all("*", (c) => c.text("Not Found", 404));
@@ -93,31 +86,35 @@ export function createRouterApp(options: RouterAppOptions) {
     c: Context,
     request: Request,
     style: ProviderStyle,
-    handler: (opts: any) => Promise<Response>,
+    handler: ProtocolHandler,
     forceStreaming?: boolean,
   ): Promise<Response> {
     const env = honoEnv(c);
     const incomingExecutionId = `incoming_${crypto.randomUUID()}`;
-    const collector = createTraceCollector();
-    const onTrace = options.hooks?.onTrace;
-    const observe = (event: Parameters<NonNullable<ExecutionRuntimeOptions["observe"]>>[0]) => {
-      collector.observe(event);
+    const telemetry = createRouterTelemetry(env);
+    const onExecutionSummary = options.hooks?.onExecutionSummary;
+    const observe = (
+      event: Parameters<NonNullable<ExecutionRuntimeOptions["observe"]>>[0],
+    ) => {
+      telemetry.observe(event);
       options.observe?.(event);
     };
     let traceFinalized = false;
     const finalizeTrace = () => {
       if (traceFinalized) return;
       traceFinalized = true;
-      if (!onTrace) return;
       runBackgroundTask(
         c,
-        () => onTrace(collector.getTrace(), env),
-        "onTrace hook",
+        async () => {
+          await telemetry.flush();
+          await onExecutionSummary?.(telemetry.summary(), env);
+        },
+        "onExecutionSummary hook",
       );
     };
 
     const requestStartedMs = Date.now();
-    observeTimingEvent({
+    observeTimedExecution({
       observe,
       kind: "request.started",
       requestId: incomingExecutionId,
@@ -128,7 +125,7 @@ export function createRouterApp(options: RouterAppOptions) {
 
     const authStartedMs = Date.now();
     const principal = await options.auth.authenticate(request, env);
-    observeTimingEvent({
+    observeTimedExecution({
       observe,
       kind: "admission.authenticate",
       requestId: incomingExecutionId,
@@ -137,14 +134,22 @@ export function createRouterApp(options: RouterAppOptions) {
       finishedAtMs: Date.now(),
       data: { authenticated: !!principal },
     });
-    if (!principal) return unauthorized();
+    if (!principal) {
+      telemetry.recordError({
+        message: "Authentication failed",
+        requestId: incomingExecutionId,
+        executionId: incomingExecutionId,
+      });
+      finalizeTrace();
+      return unauthorizedResponse();
+    }
 
     let program: Program;
     try {
       const parseStartedMs = Date.now();
       program = await parseRequestProgram(style, request.clone());
       if (forceStreaming) program = setStreaming(program, true);
-      observeTimingEvent({
+      observeTimedExecution({
         observe,
         kind: "request.parsed",
         requestId: incomingExecutionId,
@@ -154,7 +159,12 @@ export function createRouterApp(options: RouterAppOptions) {
         data: { style, streaming: forceStreaming === true },
       });
     } catch {
-      observeTimingEvent({
+      telemetry.recordError({
+        message: "Invalid request body",
+        requestId: incomingExecutionId,
+        executionId: incomingExecutionId,
+      });
+      observeTimedExecution({
         observe,
         kind: "request.parse_failed",
         requestId: incomingExecutionId,
@@ -164,13 +174,17 @@ export function createRouterApp(options: RouterAppOptions) {
         data: { style },
       });
       finalizeTrace();
-      return errorResponse("Invalid request body", 400, "invalid_request_body");
+      return createOpenAiErrorResponse(
+        "Invalid request body",
+        400,
+        "invalid_request_body",
+      );
     }
 
     const model = getModel(program) || null;
     const accessStartedMs = Date.now();
     const hasModelAccess = !model || canAccessPrincipalModel(principal, model);
-    observeTimingEvent({
+    observeTimedExecution({
       observe,
       kind: "admission.model_access",
       requestId: incomingExecutionId,
@@ -180,14 +194,28 @@ export function createRouterApp(options: RouterAppOptions) {
       data: { model: model ?? undefined, allowed: hasModelAccess },
     });
     if (!hasModelAccess) {
+      telemetry.recordError({
+        message: "Model access denied",
+        requestId: incomingExecutionId,
+        executionId: incomingExecutionId,
+      });
       finalizeTrace();
-      return errorResponse(`Model \`${model}\` does not exist or you do not have access.`, 404, "model_not_found");
+      return createOpenAiErrorResponse(
+        `Model \`${model}\` does not exist or you do not have access.`,
+        404,
+        "model_not_found",
+      );
     }
 
     if (options.hooks?.beforeRequest) {
       const hookStartedMs = Date.now();
-      const hookResponse = await options.hooks.beforeRequest({ request, model, principal, env });
-      observeTimingEvent({
+      const hookResponse = await options.hooks.beforeRequest({
+        request,
+        model,
+        principal,
+        env,
+      });
+      observeTimedExecution({
         observe,
         kind: "request.before_hook",
         requestId: incomingExecutionId,
@@ -197,6 +225,13 @@ export function createRouterApp(options: RouterAppOptions) {
         data: { returnedResponse: !!hookResponse },
       });
       if (hookResponse) {
+        if (hookResponse.status >= 400) {
+          telemetry.recordError({
+            message: `Request hook returned ${hookResponse.status}`,
+            requestId: incomingExecutionId,
+            executionId: incomingExecutionId,
+          });
+        }
         finalizeTrace();
         return hookResponse;
       }
@@ -211,7 +246,7 @@ export function createRouterApp(options: RouterAppOptions) {
     for (const driver of runtime.upstreamAuthChain) {
       const collectStartedMs = Date.now();
       driver.collectIncoming?.(ctx);
-      observeTimingEvent({
+      observeTimedExecution({
         observe,
         kind: "upstream_auth.collect_incoming",
         requestId: incomingExecutionId,
@@ -232,10 +267,14 @@ export function createRouterApp(options: RouterAppOptions) {
         ...(options.transforms ? { transforms: options.transforms } : {}),
         observe,
         incomingExecutionId,
-        ...(options.upstreamTimeoutMs !== undefined ? { upstreamTimeoutMs: options.upstreamTimeoutMs } : {}),
-        ...(options.remoteMcpClientFactory ? { remoteMcpClientFactory: options.remoteMcpClientFactory } : {}),
+        ...(options.upstreamTimeoutMs !== undefined
+          ? { upstreamTimeoutMs: options.upstreamTimeoutMs }
+          : {}),
+        ...(options.remoteMcpClientFactory
+          ? { remoteMcpClientFactory: options.remoteMcpClientFactory }
+          : {}),
       });
-      observeTimingEvent({
+      observeTimedExecution({
         observe,
         kind: "response.ready",
         requestId: incomingExecutionId,
@@ -252,8 +291,14 @@ export function createRouterApp(options: RouterAppOptions) {
         finalizeTrace();
         return response;
       }
-      return wrapResponseWithFinalize(response, finalizeTrace);
+      return finalizeWhenStreamCloses(response, finalizeTrace);
     } catch (error) {
+      telemetry.recordError({
+        message:
+          error instanceof Error ? error.message : "Request execution failed",
+        requestId: incomingExecutionId,
+        executionId: incomingExecutionId,
+      });
       finalizeTrace();
       throw error;
     }
@@ -261,101 +306,3 @@ export function createRouterApp(options: RouterAppOptions) {
 
   return app;
 }
-
-function honoEnv(c: Context): Record<string, unknown> {
-  return (c.env ?? {}) as Record<string, unknown>;
-}
-
-function parseGoogleGenAIRoute(request: Request): { model: string; stream: boolean } | null {
-  const pathname = new URL(request.url).pathname;
-  const match = pathname.match(/^\/v1\/models\/(.+):(generateContent|streamGenerateContent)$/);
-  if (!match?.[1] || !match[2]) return null;
-  try {
-    return { model: decodeURIComponent(match[1]), stream: match[2] === "streamGenerateContent" };
-  } catch {
-    return null;
-  }
-}
-
-async function rewriteGoogleGenAIRequest(
-  request: Request,
-  route: { model: string; stream: boolean },
-): Promise<Request> {
-  const bodyText = await request.text();
-  const headers = new Headers(request.headers);
-  try {
-    const raw = JSON.parse(bodyText) as Record<string, unknown>;
-    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-      return new Request(request.url, {
-        method: request.method,
-        headers,
-        body: JSON.stringify({ ...raw, model: route.model, ...(route.stream ? { stream: true } : {}) }),
-      });
-    }
-  } catch {}
-  return new Request(request.url, { method: request.method, headers, body: bodyText });
-}
-
-function unauthorized(): Response {
-  return errorResponse("Authentication required", 401, "auth_required");
-}
-
-function errorResponse(message: string, status: number, code: string): Response {
-  return new Response(
-    JSON.stringify({ error: { message, type: "invalid_request_error", param: null, code } }),
-    { status, headers: { "content-type": "application/json; charset=utf-8" } },
-  );
-}
-
-function isEventStreamResponse(response: Response): boolean {
-  const contentType = response.headers.get("content-type") ?? "";
-  return contentType.startsWith("text/event-stream");
-}
-
-function runBackgroundTask(c: Context, task: () => unknown, label: string): void {
-  const tracked = Promise.resolve()
-    .then(task)
-    .catch((error) => {
-      console.error(`[open-ai-router] ${label} failed:`, error);
-    });
-  let executionCtx: { waitUntil?(promise: Promise<unknown>): void } | undefined;
-  try {
-    executionCtx = c.executionCtx as { waitUntil?(promise: Promise<unknown>): void } | undefined;
-  } catch {
-    executionCtx = undefined;
-  }
-  if (executionCtx?.waitUntil) {
-    executionCtx.waitUntil(tracked);
-    return;
-  }
-  void tracked;
-}
-
-function wrapResponseWithFinalize(response: Response, finalize: () => void): Response {
-  const reader = response.body!.getReader();
-  const body = new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          finalize();
-          controller.close();
-          return;
-        }
-        controller.enqueue(value);
-      } catch (error) {
-        finalize();
-        controller.error(error);
-      }
-    },
-    async cancel(reason) {
-      finalize();
-      await reader.cancel(reason).catch(() => {});
-    },
-  });
-  return new Response(body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: new Headers(response.headers),
-  });
-}

package/src/app/google-genai-route.ts

@@ -0,0 +1,48 @@
+type GoogleGenAIRoute = { model: string; stream: boolean };
+
+export function parseGoogleGenAIRoute(
+  request: Request,
+): GoogleGenAIRoute | null {
+  const pathname = new URL(request.url).pathname;
+  const match = pathname.match(
+    /^\/v1\/models\/(.+):(generateContent|streamGenerateContent)$/,
+  );
+  if (!match?.[1] || !match[2]) return null;
+  try {
+    return {
+      model: decodeURIComponent(match[1]),
+      stream: match[2] === "streamGenerateContent",
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function rewriteGoogleGenAIRequest(
+  request: Request,
+  route: GoogleGenAIRoute,
+): Promise<Request> {
+  const bodyText = await request.text();
+  const headers = new Headers(request.headers);
+  try {
+    const raw: unknown = JSON.parse(bodyText);
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return new Request(request.url, {
+        method: request.method,
+        headers,
+        body: JSON.stringify({
+          ...raw,
+          model: route.model,
+          ...(route.stream ? { stream: true } : {}),
+        }),
+      });
+    }
+  } catch {
+    // The protocol parser returns the canonical invalid-body response.
+  }
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body: bodyText,
+  });
+}