@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/dist/models/google/middleware.js

@@ -11,14 +11,15 @@ export const geminiDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["google"] ??= {})["outputDimensionality"] = dimensions;
+        const target = (params.providerOptions["google"] ??= {});
+        target.outputDimensionality = dimensions;
         delete unknown["dimensions"];
         return params;
     },
 };
 // https://ai.google.dev/gemini-api/docs/thinking#thinking-levels
 export function mapGeminiReasoningEffort(effort, modelId) {
-    if (modelId.includes("gemini-3.1-pro")) {
+    if (modelId.includes("pro")) {
         switch (effort) {
             case "none":
             case "minimal":
@@ -28,26 +29,22 @@ export function mapGeminiReasoningEffort(effort, modelId) {
                 return "medium";
             case "high":
             case "xhigh":
-            case "max":
                 return "high";
         }
     }
-    if (modelId.includes("gemini-3-flash") || modelId.includes("gemini-3.1-flash")) {
-        switch (effort) {
-            case "none":
-            case "minimal":
-                return "minimal";
-            case "low":
-                return "low";
-            case "medium":
-                return "medium";
-            case "high":
-            case "xhigh":
-            case "max":
-                return "high";
-        }
+    // Flash
+    switch (effort) {
+        case "none":
+        case "minimal":
+            return "minimal";
+        case "low":
+            return "low";
+        case "medium":
+            return "medium";
+        case "high":
+        case "xhigh":
+            return "high";
     }
-    return effort;
 }
 export const GEMINI_DEFAULT_MAX_OUTPUT_TOKENS = 65536;
 export const GEMINI_2_5_PRO_MIN_THINKING_BUDGET = 128;
@@ -58,6 +55,9 @@ export const geminiReasoningMiddleware = {
         const unknown = params.providerOptions?.["unknown"];
         if (!unknown)
             return params;
+        // If thinking options exist, just pass through
+        if (unknown["thinking_config"])
+            return params;
         const reasoning = unknown["reasoning"];
         if (!reasoning)
             return params;
@@ -65,19 +65,19 @@ export const geminiReasoningMiddleware = {
         const modelId = model.modelId;
         if (modelId.includes("gemini-2")) {
             const is25Pro = modelId.includes("gemini-2.5-pro");
-            target["thinkingConfig"] = {
+            target.thinkingConfig = {
                 thinkingBudget: reasoning.max_tokens ??
                     calculateReasoningBudgetFromEffort(reasoning.effort ?? "none", params.maxOutputTokens ?? GEMINI_DEFAULT_MAX_OUTPUT_TOKENS, is25Pro ? GEMINI_2_5_PRO_MIN_THINKING_BUDGET : 0),
             };
         }
         else if (modelId.includes("gemini-3") && reasoning.effort) {
-            target["thinkingConfig"] = {
+            target.thinkingConfig = {
                 thinkingLevel: mapGeminiReasoningEffort(reasoning.effort, modelId),
             };
             // FUTURE: warn if model is gemini-3 and max_tokens (unsupported) was ignored
         }
-        (target["thinkingConfig"] ??= {})["includeThoughts"] =
-            reasoning.enabled ? !reasoning.exclude : false;
+        const thinkingConfig = (target.thinkingConfig ??= {});
+        thinkingConfig.includeThoughts = reasoning.enabled ? !reasoning.exclude : false;
         delete unknown["reasoning"];
         return params;
     },
@@ -91,9 +91,13 @@ export const geminiPromptCachingMiddleware = {
         const unknown = params.providerOptions?.["unknown"];
         if (!unknown)
             return params;
-        const cachedContent = unknown["cached_content"];
-        if (cachedContent) {
-            (params.providerOptions["google"] ??= {})["cachedContent"] = cachedContent;
+        // If cached_content options exist, just pass through
+        if (unknown["cached_content"])
+            return params;
+        const promptCacheKey = unknown["prompt_cache_key"];
+        if (promptCacheKey) {
+            (params.providerOptions["google"] ??= {}).cachedContent =
+                promptCacheKey;
         }
         delete unknown["cached_content"];
         return params;

package/dist/models/openai/middleware.js

@@ -10,21 +10,25 @@ export const openAIDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["openai"] ??= {})["dimensions"] = dimensions;
+        const target = (params.providerOptions["openai"] ??= {});
+        target.dimensions = dimensions;
         delete unknown["dimensions"];
         return params;
     },
 };
 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 = {
@@ -41,13 +45,13 @@ export const openAIReasoningMiddleware = {
         const isGptOss = model.modelId.includes("gpt-oss");
         if (isGptOss) {
             // FUTURE: warn that unable to disable reasoning for gpt-oss models
-            target["reasoningEffort"] = mapGptOssReasoningEffort(reasoning.effort);
+            target.reasoningEffort = mapGptOssReasoningEffort(reasoning.effort);
         }
         else if (reasoning.enabled === false) {
-            target["reasoningEffort"] = "none";
+            target.reasoningEffort = "none";
         }
         else if (reasoning.effort) {
-            target["reasoningEffort"] = reasoning.effort;
+            target.reasoningEffort = reasoning.effort;
         }
         // FUTURE: warn that reasoning.max_tokens (not supported) was ignored
         delete unknown["reasoning"];
@@ -67,9 +71,9 @@ export const openAIPromptCachingMiddleware = {
         if (key || retention) {
             const target = (params.providerOptions["openai"] ??= {});
             if (key)
-                target["promptCacheKey"] = key;
+                target.promptCacheKey = key;
             if (retention)
-                target["promptCacheRetention"] = retention;
+                target.promptCacheRetention = retention;
         }
         delete unknown["prompt_cache_key"];
         delete unknown["prompt_cache_retention"];

package/dist/models/voyage/middleware.js

@@ -10,7 +10,8 @@ export const voyageDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["voyage"] ??= {})["outputDimension"] = dimensions;
+        const target = (params.providerOptions["voyage"] ??= {});
+        target.outputDimension = dimensions;
         delete unknown["dimensions"];
         return params;
     },

package/dist/providers/bedrock/middleware.js

@@ -7,14 +7,15 @@ export const bedrockGptReasoningMiddleware = {
         if (!model.modelId.includes("gpt"))
             return params;
         const bedrock = params.providerOptions?.["bedrock"];
-        if (!bedrock || typeof bedrock !== "object")
+        if (!bedrock)
             return params;
-        const effort = bedrock["reasoningEffort"];
+        const effort = bedrock.reasoningEffort;
         if (effort === undefined)
             return params;
-        const target = (bedrock["reasoningConfig"] ??= {});
-        target["maxReasoningEffort"] = effort;
-        delete bedrock["reasoningEffort"];
+        const target = (bedrock.reasoningConfig ??= {});
+        // @ts-expect-error AI SDK does accept this
+        target.maxReasoningEffort = effort;
+        delete bedrock.reasoningEffort;
         return params;
     },
 };
@@ -25,28 +26,25 @@ export const bedrockClaudeReasoningMiddleware = {
         if (!model.modelId.includes("claude"))
             return params;
         const bedrock = params.providerOptions?.["bedrock"];
-        if (!bedrock || typeof bedrock !== "object")
+        if (!bedrock)
             return params;
-        const thinking = bedrock["thinking"];
-        const effort = bedrock["effort"];
+        const thinking = bedrock.thinking;
+        const effort = bedrock.effort;
         if (!thinking && effort === undefined)
             return params;
-        const target = (bedrock["reasoningConfig"] ??= {});
+        const target = (bedrock.reasoningConfig ??= {});
         if (thinking && typeof thinking === "object") {
-            const thinkingOptions = thinking;
-            if (thinkingOptions["type"] !== undefined) {
-                target["type"] = thinkingOptions["type"];
-            }
-            if (thinkingOptions["budgetTokens"] !== undefined) {
-                target["budgetTokens"] = thinkingOptions["budgetTokens"];
+            target.type = thinking.type;
+            if ("budgetTokens" in thinking && thinking.budgetTokens !== undefined) {
+                target.budgetTokens = thinking.budgetTokens;
             }
         }
         // FUTURE: bedrock currently does not support "effort" for other 4.x models
         if (effort !== undefined && isClaude46(model.modelId)) {
-            target["maxReasoningEffort"] = effort;
+            target.maxReasoningEffort = effort;
         }
-        delete bedrock["thinking"];
-        delete bedrock["effort"];
+        delete bedrock.thinking;
+        delete bedrock.effort;
         return params;
     },
 };
@@ -79,18 +77,18 @@ export const bedrockPromptCachingMiddleware = {
             delete entryBedrock["cacheControl"];
         };
         for (const message of params.prompt) {
-            processCacheControl(message["providerOptions"]);
-            if (!Array.isArray(message["content"]))
+            processCacheControl(message.providerOptions);
+            if (!Array.isArray(message.content))
                 continue;
-            for (const part of message["content"]) {
-                processCacheControl(part["providerOptions"]);
+            for (const part of message.content) {
+                processCacheControl(part.providerOptions);
             }
             lastCacheableBlock = message;
         }
         const bedrock = params.providerOptions?.["bedrock"];
         const cacheControl = bedrock?.["cacheControl"];
         if (cacheControl && !hasExplicitCacheControl && lastCacheableBlock) {
-            ((lastCacheableBlock["providerOptions"] ??= {})["bedrock"] ??= {})["cachePoint"] =
+            ((lastCacheableBlock.providerOptions ??= {})["bedrock"] ??= {})["cachePoint"] =
                 toBedrockCachePoint(model.modelId, cacheControl);
         }
         delete bedrock?.["cacheControl"];

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 };