@hebo-ai/gateway 0.6.1 → 0.6.2-rc1

package/README.md

@@ -569,7 +569,7 @@ Accepted request fields:
 
 - `prompt_cache_key` + `prompt_cache_retention` (OpenAI style)
 - `cache_control` (OpenRouter / Vercel / Claude style)
-- `cached_content` (Gemini style)
+- `extra_body { google: { cached_content } }` (Gemini style)
 
 ```json
 {

package/dist/endpoints/chat-completions/converters.js

@@ -6,9 +6,9 @@ import { toResponse } from "../../utils/response";
 import { parseDataUrl } from "../../utils/url";
 // --- Request Flow ---
 export function convertToTextCallOptions(params) {
-    const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, response_format, reasoning_effort, reasoning, prompt_cache_key, prompt_cache_retention, cached_content, cache_control, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
+    const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, response_format, reasoning_effort, reasoning, prompt_cache_key, prompt_cache_retention, extra_body, cache_control, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
     Object.assign(rest, parseReasoningOptions(reasoning_effort, reasoning));
-    Object.assign(rest, parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, cached_content, cache_control));
+    Object.assign(rest, parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, extra_body?.google?.cached_content, cache_control));
     const { toolChoice, activeTools } = convertToToolChoiceOptions(tool_choice);
     return {
         messages: convertToModelMessages(messages),
@@ -192,7 +192,7 @@ export function fromChatCompletionsContent(content) {
                 return fromFilePart(part.file.data, part.file.media_type, part.file.filename, part.cache_control);
             case "input_audio":
                 return fromFilePart(part.input_audio.data, `audio/${part.input_audio.format}`, undefined, part.cache_control);
-            default: {
+            case "text": {
                 const out = {
                     type: "text",
                     text: part.text,
@@ -204,6 +204,8 @@ export function fromChatCompletionsContent(content) {
                 }
                 return out;
             }
+            default:
+                throw new Error(`Unhandled content part type: ${part.type}`);
         }
     });
 }
@@ -305,6 +307,7 @@ function parseToolResult(content) {
 }
 function parseJsonOrText(content) {
     try {
+        // oxlint-disable-next-line no-unsafe-assignment
         return { type: "json", value: JSON.parse(content) };
     }
     catch {
@@ -414,6 +417,7 @@ export class ChatCompletionsStream extends TransformStream {
         };
         super({
             transform(part, controller) {
+                // oxlint-disable-next-line switch-exhaustiveness-check
                 switch (part.type) {
                     case "text-delta": {
                         controller.enqueue(createChunk({ role: "assistant", content: part.text }, part.providerMetadata));

package/dist/endpoints/chat-completions/handler.js

@@ -23,6 +23,7 @@ export const chatCompletions = (config) => {
         }
         // Parse + validate input.
         try {
+            // oxlint-disable-next-line no-unsafe-assignment
             ctx.body = await ctx.request.json();
         }
         catch {
@@ -66,6 +67,7 @@ export const chatCompletions = (config) => {
         const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
+        // oxlint-disable-next-line no-unsafe-argument
         const textOptions = convertToTextCallOptions(inputs);
         logger.trace({
             requestId: ctx.requestId,

package/dist/endpoints/chat-completions/otel.js

@@ -96,7 +96,7 @@ const toMessageParts = (message) => {
         case "system":
             return toTextParts(message.content);
         default:
-            return [];
+            throw new Error(`Unhandled content part type: ${message.role}`);
     }
 };
 export const getChatRequestAttributes = (inputs, signalLevel) => {

package/dist/endpoints/chat-completions/schema.d.ts

@@ -658,7 +658,11 @@ declare const ChatCompletionsInputsSchema: z.ZodObject<{
         in_memory: "in_memory";
         "24h": "24h";
     }>>;
-    cached_content: z.ZodOptional<z.ZodString>;
+    extra_body: z.ZodOptional<z.ZodObject<{
+        google: z.ZodOptional<z.ZodObject<{
+            cached_content: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     cache_control: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"ephemeral">;
         ttl: z.ZodOptional<z.ZodString>;
@@ -866,7 +870,11 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
         in_memory: "in_memory";
         "24h": "24h";
     }>>;
-    cached_content: z.ZodOptional<z.ZodString>;
+    extra_body: z.ZodOptional<z.ZodObject<{
+        google: z.ZodOptional<z.ZodObject<{
+            cached_content: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     cache_control: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"ephemeral">;
         ttl: z.ZodOptional<z.ZodString>;

package/dist/endpoints/chat-completions/schema.js

@@ -213,7 +213,17 @@ const ChatCompletionsInputsSchema = z.object({
     prompt_cache_key: z.string().optional(),
     prompt_cache_retention: z.enum(["in_memory", "24h"]).optional(),
     // Extension origin: Gemini explicit cache handle
-    cached_content: z.string().optional().meta({ extension: true }),
+    // FUTURE: generalize extra_body handling
+    // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/migrate/openai/overview
+    extra_body: z
+        .object({
+        google: z
+            .object({
+            cached_content: z.string().optional().meta({ extension: true }),
+        })
+            .optional(),
+    })
+        .optional(),
     // Extension origin: OpenRouter/Vercel/Anthropic
     cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
     // Extension origin: OpenRouter

package/dist/endpoints/embeddings/handler.js

@@ -23,6 +23,7 @@ export const embeddings = (config) => {
         }
         // Parse + validate input.
         try {
+            // oxlint-disable-next-line no-unsafe-assignment
             ctx.body = await ctx.request.json();
         }
         catch {
@@ -65,6 +66,7 @@ export const embeddings = (config) => {
         const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
+        // oxlint-disable-next-line no-unsafe-argument
         const embedOptions = convertToEmbedCallOptions(inputs);
         logger.trace({ requestId: ctx.requestId, options: embedOptions }, "[embeddings] AI SDK options");
         addSpanEvent("hebo.options.prepared");

package/dist/endpoints/models/converters.js

@@ -12,13 +12,13 @@ export function toModel(id, catalogModel) {
         id,
         object: "model",
         created: createdTimestamp,
-        owned_by: id.split("/")[0] || "system",
+        owned_by: id.split("/")[0] ?? "system",
         architecture: {
-            input_modalities: modalities?.input || [],
+            input_modalities: modalities?.input ?? [],
             modality: modalities?.input &&
                 modalities?.output &&
                 `${modalities.input?.[0]}->${modalities.output?.[0]}`,
-            output_modalities: modalities?.output || [],
+            output_modalities: modalities?.output ?? [],
         },
         endpoints: providers?.map((provider) => ({
             tag: provider,

package/dist/lifecycle.js

@@ -6,7 +6,7 @@ import { getBaggageAttributes } from "./telemetry/baggage";
 import { instrumentFetch } from "./telemetry/fetch";
 import { recordRequestDuration } from "./telemetry/gen-ai";
 import { getRequestAttributes, getResponseAttributes } from "./telemetry/http";
-import { recordV8jsMemory } from "./telemetry/memory";
+import { observeV8jsMemoryMetrics } from "./telemetry/memory";
 import { addSpanEvent, setSpanEventsEnabled, setSpanTracer, startSpan } from "./telemetry/span";
 import { wrapStream } from "./telemetry/stream";
 import { resolveOrCreateRequestId } from "./utils/request";
@@ -17,6 +17,7 @@ export const winterCgHandler = (run, config) => {
         setSpanTracer(parsedConfig.telemetry?.tracer);
         setSpanEventsEnabled(parsedConfig.telemetry?.signals?.hebo);
         instrumentFetch(parsedConfig.telemetry?.signals?.hebo);
+        observeV8jsMemoryMetrics(parsedConfig.telemetry?.signals?.hebo);
     }
     return async (request, state) => {
         const start = performance.now();
@@ -57,7 +58,6 @@ export const winterCgHandler = (run, config) => {
             if (ctx.operation === "chat" || ctx.operation === "embeddings") {
                 recordRequestDuration(performance.now() - start, realStatus, ctx, parsedConfig.telemetry?.signals?.gen_ai);
             }
-            recordV8jsMemory(parsedConfig.telemetry?.signals?.hebo);
             span.finish();
         };
         try {

package/dist/logger/default.js

@@ -37,8 +37,6 @@ function serializeError(err, _seen) {
     return out;
 }
 const buildLogObject = (level, args) => {
-    if (args.length === 0)
-        return {};
     const [first, second] = args;
     let obj;
     let err;
@@ -70,7 +68,9 @@ const buildLogObject = (level, args) => {
         ...obj,
     };
 };
-const makeLogFn = (level, write) => (...args) => write(JSON.stringify(buildLogObject(level, args)));
+const makeLogFn = (level, write) => (...args) => {
+    write(JSON.stringify(buildLogObject(level, args)));
+};
 export const createDefaultLogger = (config) => {
     if (config.level === "silent" || getDefaultLogLevel() === "silent") {
         return { trace: noop, debug: noop, info: noop, warn: noop, error: noop };

package/dist/logger/index.d.ts

@@ -1,8 +1,5 @@
-export type LogFn = {
-    (msg: string): void;
-    (obj: Record<string, unknown>, msg?: string): void;
-    (err: Error, msg?: string): void;
-};
+export type LogArgs = [msg: string] | [obj: Record<string, unknown>, msg?: string] | [err: Error, msg?: string];
+export type LogFn = (...args: LogArgs) => void;
 export type Logger = Record<"trace" | "debug" | "info" | "warn" | "error", LogFn>;
 export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "silent";
 export type LoggerConfig = {

package/dist/middleware/common.js

@@ -1,4 +1,5 @@
 function snakeToCamel(key) {
+    // oxlint-disable-next-line prefer-includes
     if (key.indexOf("_") === -1)
         return key;
     let out = "";

package/dist/middleware/utils.js

@@ -20,8 +20,6 @@ export function calculateReasoningBudgetFromEffort(effort, maxTokens, minTokens
         case "max":
             percentage = 0.95;
             break;
-        default:
-            return 0;
     }
     return Math.max(minTokens, Math.floor(maxTokens * percentage));
 }

package/dist/models/amazon/middleware.js

@@ -17,6 +17,8 @@ export const novaDimensionsMiddleware = {
 };
 function mapNovaEffort(effort) {
     switch (effort) {
+        case "none":
+            return;
         case "minimal":
         case "low":
             return "low";

package/dist/models/catalog.js

@@ -1,4 +1,8 @@
 export function defineModelCatalog(...inputs) {
     const catalogs = inputs.flat().map((input) => (typeof input === "function" ? input() : input));
-    return Object.assign({}, ...catalogs);
+    const out = {};
+    for (const catalog of catalogs) {
+        Object.assign(out, catalog);
+    }
+    return out;
 }

package/dist/models/openai/middleware.js

@@ -17,14 +17,18 @@ export const openAIDimensionsMiddleware = {
 };
 function mapGptOssReasoningEffort(effort) {
     switch (effort) {
+        case undefined:
+        case "none":
+            return;
+        case "minimal":
+        case "low":
+            return "low";
         case "medium":
             return "medium";
         case "high":
         case "xhigh":
         case "max":
             return "high";
-        default:
-            return "low";
     }
 }
 export const openAIReasoningMiddleware = {

package/dist/providers/registry.js

@@ -55,7 +55,9 @@ export const withCanonicalIds = (provider, config = {}) => {
     };
     const needsFallbackWrap = stripNamespace || normalizeDelimiters || namespaceSeparator !== "/" || !!prefix || !!postfix;
     // FUTURE: use embeddingModel instead of textEmbeddingModel once voyage supports it
+    // oxlint-disable-next-line unbound-method
     const languageModel = provider.languageModel;
+    // oxlint-disable-next-line unbound-method, no-deprecated
     const embeddingModel = provider.textEmbeddingModel;
     const fallbackProvider = needsFallbackWrap
         ? {
@@ -69,6 +71,7 @@ export const withCanonicalIds = (provider, config = {}) => {
             embeddingModel: (id) => {
                 const mapped = applyFallbackAffixes(normalizeId(id));
                 logger.debug(`[canonical] mapped ${id} to ${mapped}`);
+                // oxlint-disable-next-line no-deprecated
                 return embeddingModel(mapped);
             },
         }

package/dist/telemetry/fetch.js

@@ -16,8 +16,13 @@ const getRequestAttributes = (input, init) => {
         attrs["url.full"] = input.url;
     return attrs;
 };
-const shouldTraceFetch = (init) => typeof init?.headers?.["user-agent"] === "string" &&
-    init.headers["user-agent"].indexOf("ai-sdk/provider-utils") !== -1;
+const shouldTraceFetch = (init) => {
+    const h = init?.headers;
+    if (!h || typeof h !== "object" || Array.isArray(h) || h instanceof Headers)
+        return false;
+    const ua = h["user-agent"];
+    return typeof ua === "string" && ua.includes("ai-sdk/provider-utils");
+};
 const otelFetch = (input, init) => {
     const original = g[ORIGINAL_FETCH_KEY];
     if (!fetchTracingEnabled)

package/dist/telemetry/gen-ai.js

@@ -1,7 +1,10 @@
 import { metrics } from "@opentelemetry/api";
 import { STATUS_CODE } from "../errors/utils";
-const meter = metrics.getMeter("@hebo/gateway");
-const requestDurationHistogram = meter.createHistogram("gen_ai.server.request.duration", {
+const getMeter = () => metrics.getMeter("@hebo/gateway");
+let requestDurationHistogram;
+let timePerOutputTokenHistogram;
+let tokenUsageHistogram;
+const getRequestDurationHistogram = () => (requestDurationHistogram ??= getMeter().createHistogram("gen_ai.server.request.duration", {
     description: "End-to-end gateway request duration",
     unit: "s",
     advice: {
@@ -9,8 +12,8 @@ const requestDurationHistogram = meter.createHistogram("gen_ai.server.request.du
             0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 240,
         ],
     },
-});
-const timePerOutputTokenHistogram = meter.createHistogram("gen_ai.server.time_per_output_token", {
+}));
+const getTimePerOutputTokenHistogram = () => (timePerOutputTokenHistogram ??= getMeter().createHistogram("gen_ai.server.time_per_output_token", {
     description: "End-to-end gateway request duration per output token",
     unit: "s",
     advice: {
@@ -18,17 +21,17 @@ const timePerOutputTokenHistogram = meter.createHistogram("gen_ai.server.time_pe
             0.01, 0.025, 0.05, 0.075, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.75, 1.0, 2.5,
         ],
     },
-});
-const tokenUsageHistogram = meter.createHistogram("gen_ai.client.token.usage", {
+}));
+const getTokenUsageHistogram = () => (tokenUsageHistogram ??= getMeter().createHistogram("gen_ai.client.token.usage", {
     description: "Token usage reported by upstream model responses",
     unit: "{token}",
     advice: {
         explicitBucketBoundaries: [
-            1, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-            524288, 1048576,
+            1, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072,
+            262144, 524288, 1048576,
         ],
     },
-});
+}));
 export const getGenAiGeneralAttributes = (ctx, signalLevel) => {
     if (!signalLevel || signalLevel === "off")
         return {};
@@ -47,7 +50,7 @@ export const recordRequestDuration = (duration, status, ctx, signalLevel) => {
     if (status !== 200) {
         attrs["error.type"] = `${status} ${STATUS_CODE(status).toLowerCase()}`;
     }
-    requestDurationHistogram.record(duration / 1000, attrs);
+    getRequestDurationHistogram().record(duration / 1000, attrs);
 };
 // FUTURE: record unsuccessful calls
 export const recordTimePerOutputToken = (start, tokenAttrs, metricAttrs, signalLevel) => {
@@ -56,7 +59,7 @@ export const recordTimePerOutputToken = (start, tokenAttrs, metricAttrs, signalL
     const outputTokens = tokenAttrs["gen_ai.usage.output_tokens"];
     if (typeof outputTokens !== "number" || outputTokens <= 0)
         return;
-    timePerOutputTokenHistogram.record((performance.now() - start) / 1000 / outputTokens, metricAttrs);
+    getTimePerOutputTokenHistogram().record((performance.now() - start) / 1000 / outputTokens, metricAttrs);
 };
 // FUTURE: record unsuccessful calls
 export const recordTokenUsage = (tokenAttrs, metricAttrs, signalLevel) => {
@@ -65,7 +68,7 @@ export const recordTokenUsage = (tokenAttrs, metricAttrs, signalLevel) => {
     const record = (value, tokenType) => {
         if (typeof value !== "number")
             return;
-        tokenUsageHistogram.record(value, Object.assign({}, metricAttrs, { "gen_ai.token.type": tokenType }));
+        getTokenUsageHistogram().record(value, Object.assign({}, metricAttrs, { "gen_ai.token.type": tokenType }));
     };
     record(tokenAttrs["gen_ai.usage.input_tokens"], "input");
     record(tokenAttrs["gen_ai.usage.output_tokens"], "output");

package/dist/telemetry/memory.d.ts

@@ -1,2 +1,2 @@
 import type { TelemetrySignalLevel } from "../types";
-export declare const recordV8jsMemory: (level?: TelemetrySignalLevel) => void;
+export declare const observeV8jsMemoryMetrics: (level?: TelemetrySignalLevel) => void;

package/dist/telemetry/memory.js

@@ -1,18 +1,9 @@
 import { metrics } from "@opentelemetry/api";
-const meter = metrics.getMeter("@hebo/gateway");
+const getMeter = () => metrics.getMeter("@hebo/gateway");
 const defaultHeapSpaceAttrs = { "v8js.heap.space.name": "total" };
-const heapUsedCounter = meter.createUpDownCounter("v8js.memory.heap.used", {
-    description: "Used bytes in the V8 heap",
-    unit: "By",
-});
-const heapSpacePhysicalSizeCounter = meter.createUpDownCounter("v8js.memory.heap.space.physical_size", {
-    description: "Physical bytes allocated for the V8 heap space",
-    unit: "By",
-});
+let registered = false;
 const isEnabled = (level) => level === "recommended" || level === "full";
-export const recordV8jsMemory = (level) => {
-    if (!isEnabled(level))
-        return;
+const observeMemory = (observe) => {
     let usage;
     try {
         usage = globalThis.process?.memoryUsage?.();
@@ -22,6 +13,31 @@ export const recordV8jsMemory = (level) => {
     }
     if (!usage)
         return;
-    heapUsedCounter.add(usage.heapUsed, defaultHeapSpaceAttrs);
-    heapSpacePhysicalSizeCounter.add(usage.rss, defaultHeapSpaceAttrs);
+    observe(usage.heapUsed, usage.rss);
+};
+export const observeV8jsMemoryMetrics = (level) => {
+    if (!isEnabled(level) || registered)
+        return;
+    registered = true;
+    const meter = getMeter();
+    meter
+        .createObservableGauge("v8js.memory.heap.used", {
+        description: "Used bytes in the V8 heap",
+        unit: "By",
+    })
+        .addCallback((result) => {
+        observeMemory((heapUsed) => {
+            result.observe(heapUsed, defaultHeapSpaceAttrs);
+        });
+    });
+    meter
+        .createObservableGauge("v8js.memory.heap.space.physical_size", {
+        description: "Physical bytes allocated for the V8 heap space",
+        unit: "By",
+    })
+        .addCallback((result) => {
+        observeMemory((_, rss) => {
+            result.observe(rss, defaultHeapSpaceAttrs);
+        });
+    });
 };

package/dist/telemetry/span.js

@@ -34,7 +34,7 @@ export const startSpan = (name, options) => {
 };
 export const withSpan = async (name, run, options) => {
     if (!spanTracer) {
-        return await run();
+        return run();
     }
     const started = startSpan(name, options);
     try {

package/dist/telemetry/stream.js

@@ -1,51 +1,58 @@
 import { toOpenAIError } from "../errors/openai";
-const isErrorChunk = (v) => v instanceof Error || !!v?.error;
+const isErrorChunk = (v) => v instanceof Error || (typeof v === "object" && v !== null && "error" in v);
 export const wrapStream = (src, hooks) => {
     let finished = false;
-    const done = (reader, controller, status, reason) => {
-        if (!finished) {
-            finished = true;
-            hooks.onDone?.(status, reason);
+    let reader;
+    const done = (controller, status, reason) => {
+        if (finished)
+            return;
+        finished = true;
+        hooks.onDone?.(status, reason);
+        if (status !== 200) {
+            reader?.cancel(reason).catch(() => { });
+        }
+        try {
+            controller.close();
         }
-        reader.cancel(reason).catch(() => { });
-        controller.close();
+        catch { }
     };
     return new ReadableStream({
         async start(controller) {
-            const reader = src.getReader();
+            reader = src.getReader();
             try {
                 for (;;) {
-                    // oxlint-disable-next-line no-await-in-loop
+                    // oxlint-disable-next-line no-await-in-loop, no-unsafe-assignment
                     const { value, done: eof } = await reader.read();
                     if (eof)
                         break;
-                    const out = isErrorChunk(value) ? toOpenAIError(value) : value;
-                    controller.enqueue(out);
-                    if (out !== value) {
-                        const status = out.error?.type === "invalid_request_error" ? 422 : 502;
-                        done(reader, controller, status, value);
+                    controller.enqueue(value);
+                    if (isErrorChunk(value)) {
+                        done(controller, toOpenAIError(value).error.type === "invalid_request_error" ? 422 : 502, value);
                         return;
                     }
                 }
-                done(reader, controller, 200);
+                done(controller, 200);
             }
             catch (err) {
-                controller.enqueue(toOpenAIError(err));
-                done(reader, controller, 502, err);
+                try {
+                    controller.enqueue(toOpenAIError(err));
+                }
+                catch { }
+                done(controller, 502, err);
             }
             finally {
                 try {
-                    reader.releaseLock();
+                    reader?.releaseLock();
                 }
                 catch { }
             }
         },
         cancel(reason) {
-            if (!finished) {
-                finished = true;
-                hooks.onDone?.(499, reason);
-            }
-            src.cancel(reason).catch(() => { });
+            if (finished)
+                return;
+            finished = true;
+            hooks.onDone?.(499, reason);
+            reader?.cancel(reason).catch(() => { });
         },
     });
 };

package/dist/utils/env.js

@@ -1,5 +1,7 @@
 const NODE_ENV = typeof process === "undefined"
-    ? (globalThis.NODE_ENV ?? globalThis.ENV?.NODE_ENV)
-    : process.env?.NODE_ENV;
+    ? // oxlint-disable-next-line no-unsafe-member-access
+        (globalThis.NODE_ENV ?? globalThis.ENV?.NODE_ENV)
+    : // oxlint-disable-next-line no-unsafe-assignment
+        process.env?.NODE_ENV;
 export const isProduction = () => NODE_ENV === "production";
 export const isTest = () => NODE_ENV === "test";

package/dist/utils/preset.js

@@ -1,6 +1,7 @@
 function isPlainObject(v) {
     if (!v || typeof v !== "object" || Array.isArray(v))
         return false;
+    // oxlint-disable-next-line no-unsafe-assignment
     const proto = Object.getPrototypeOf(v);
     return proto === Object.prototype || proto === null;
 }

package/dist/utils/response.js

@@ -19,7 +19,9 @@ export const mergeResponseInit = (defaultHeaders, responseInit) => {
     const headers = new Headers(defaultHeaders);
     const override = responseInit?.headers;
     if (override) {
-        new Headers(override).forEach((value, key) => headers.set(key, value));
+        new Headers(override).forEach((value, key) => {
+            headers.set(key, value);
+        });
     }
     if (!responseInit)
         return { headers };