@hebo-ai/gateway 0.4.0-beta.3 → 0.4.0

package/dist/models/voyage/presets.js

@@ -2,7 +2,7 @@ import { presetFor } from "../../utils/preset";
 const VOYAGE_BASE = {
     modalities: {
         input: ["text"],
-        output: ["embeddings"],
+        output: ["embedding"],
     },
     providers: ["voyage"],
 };

package/dist/providers/registry.js

@@ -7,9 +7,9 @@ export const resolveProvider = (args) => {
     if (!catalogModel) {
         throw new GatewayError(`Model '${modelId}' not found in catalog`, 422, "MODEL_NOT_FOUND");
     }
-    const modality = operation === "embeddings" ? "embeddings" : "text";
+    const modality = operation === "embeddings" ? "embedding" : "text";
     if (catalogModel.modalities && !catalogModel.modalities.output.includes(modality)) {
-        throw new GatewayError(`Model '${modelId}' does not support '${operation}' output`, 422, "MODEL_UNSUPPORTED_OPERATION");
+        throw new GatewayError(`Model '${modelId}' does not support '${modality}' output`, 422, "MODEL_UNSUPPORTED_OPERATION");
     }
     // FUTURE: implement fallback logic [e.g. runtime config invalid]
     const resolvedProviderId = catalogModel.providers[0];

package/dist/telemetry/baggage.d.ts

@@ -0,0 +1 @@
+export declare const getBaggageAttributes: (request?: Request) => Record<string, string>;

package/dist/telemetry/baggage.js

@@ -0,0 +1,24 @@
+const HEBO_BAGGAGE_PREFIX = "hebo.";
+export const getBaggageAttributes = (request) => {
+    const h = request?.headers.get("baggage");
+    if (!h)
+        return {};
+    const attrs = {};
+    for (const part of h.split(",")) {
+        const [k, v] = part.trim().split("=", 2);
+        if (!k || !v)
+            continue;
+        const [rawValue] = v.split(";", 1);
+        if (!rawValue)
+            continue;
+        let value = rawValue;
+        try {
+            value = decodeURIComponent(rawValue);
+        }
+        catch { }
+        if (k.startsWith(HEBO_BAGGAGE_PREFIX)) {
+            attrs[k.slice(HEBO_BAGGAGE_PREFIX.length)] = value;
+        }
+    }
+    return attrs;
+};

package/dist/telemetry/fetch.d.ts

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

package/dist/telemetry/fetch.js

@@ -2,13 +2,23 @@ import { SpanKind } from "@opentelemetry/api";
 import { withSpan } from "./span";
 const ORIGINAL_FETCH_KEY = Symbol.for("@hebo/fetch/original-fetch");
 const g = globalThis;
-const perfFetch = (input, init) => {
+let fetchTracingEnabled = false;
+const shouldTraceFetch = (init) => typeof init?.headers?.["user-agent"] === "string" &&
+    init.headers["user-agent"].indexOf("ai-sdk/provider-utils") !== -1;
+const otelFetch = (input, init) => {
     const original = g[ORIGINAL_FETCH_KEY];
+    if (!fetchTracingEnabled)
+        return original(input, init);
+    if (!shouldTraceFetch(init))
+        return original(input, init);
     return withSpan("fetch", () => original(input, init), { kind: SpanKind.CLIENT });
 };
-export const initFetch = () => {
+export const initFetch = (level) => {
+    fetchTracingEnabled = level === "full";
+    if (!fetchTracingEnabled)
+        return;
     if (g[ORIGINAL_FETCH_KEY])
         return;
     g[ORIGINAL_FETCH_KEY] = globalThis.fetch.bind(globalThis);
-    globalThis.fetch = perfFetch;
+    globalThis.fetch = otelFetch;
 };

package/dist/telemetry/gen-ai.d.ts

@@ -0,0 +1,5 @@
+import { type Attributes } from "@opentelemetry/api";
+import type { TelemetrySignalLevel } from "../types";
+export declare const recordRequestDuration: (start: number, attrs: Attributes, signalLevel?: TelemetrySignalLevel) => void;
+export declare const recordTimePerOutputToken: (start: number, tokenAttrs: Attributes, metricAttrs: Attributes, signalLevel?: TelemetrySignalLevel) => void;
+export declare const recordTokenUsage: (tokenAttrs: Attributes, metricAttrs: Attributes, signalLevel?: TelemetrySignalLevel) => void;

package/dist/telemetry/gen-ai.js

@@ -0,0 +1,60 @@
+import { metrics } from "@opentelemetry/api";
+const meter = metrics.getMeter("@hebo/gateway");
+const requestDurationHistogram = meter.createHistogram("gen_ai.server.request.duration", {
+    description: "End-to-end gateway request duration",
+    unit: "s",
+    advice: {
+        explicitBucketBoundaries: [
+            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", {
+    description: "End-to-end gateway request duration per output token",
+    unit: "s",
+    advice: {
+        explicitBucketBoundaries: [
+            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", {
+    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,
+        ],
+    },
+});
+// FUTURE: record unsuccessful calls
+export const recordRequestDuration = (start, attrs, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return;
+    requestDurationHistogram.record((performance.now() - start) / 1000, attrs);
+};
+// FUTURE: record unsuccessful calls
+export const recordTimePerOutputToken = (start, tokenAttrs, metricAttrs, signalLevel) => {
+    if (!signalLevel || (signalLevel !== "recommended" && signalLevel !== "full"))
+        return;
+    const outputTokens = tokenAttrs["gen_ai.usage.output_tokens"];
+    if (typeof outputTokens !== "number" || outputTokens <= 0)
+        return;
+    timePerOutputTokenHistogram.record((performance.now() - start) / 1000 / outputTokens, metricAttrs);
+};
+// FUTURE: record unsuccessful calls
+export const recordTokenUsage = (tokenAttrs, metricAttrs, signalLevel) => {
+    if (!signalLevel || (signalLevel !== "recommended" && signalLevel !== "full"))
+        return;
+    const record = (value, tokenType) => {
+        if (typeof value !== "number")
+            return;
+        tokenUsageHistogram.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");
+    record(tokenAttrs["gen_ai.usage.total_tokens"], "total");
+    record(tokenAttrs["gen_ai.usage.cached_tokens"], "cached");
+    record(tokenAttrs["gen_ai.usage.reasoning_tokens"], "reasoning");
+};

package/dist/telemetry/http.d.ts

@@ -0,0 +1,3 @@
+import { type TelemetrySignalLevel } from "../types";
+export declare const getRequestAttributes: (request: Request, signalLevel?: TelemetrySignalLevel) => {};
+export declare const getResponseAttributes: (response: Response, signalLevel?: TelemetrySignalLevel) => {};

package/dist/telemetry/http.js

@@ -0,0 +1,57 @@
+import {} from "../types";
+import { resolveRequestId } from "../utils/headers";
+const headerArr = (h, k) => (h.has(k) ? [h.get(k)] : undefined);
+export const getRequestAttributes = (request, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    let url;
+    try {
+        // FUTURE: reuse URL from lifecycle
+        url = new URL(request.url);
+    }
+    catch { }
+    const attrs = {
+        "http.request.method": request.method,
+        "url.full": request.url,
+        "url.path": url?.pathname,
+        "url.scheme": url?.protocol.replace(":", ""),
+        "server.address": url?.hostname,
+        "server.port": url
+            ? url.port
+                ? Number(url.port)
+                : url.protocol === "https:"
+                    ? 443
+                    : 80
+            : undefined,
+    };
+    if (signalLevel !== "required") {
+        Object.assign(attrs, {
+            // FUTURE: does ElysiaJS and other frameworks attach request id?
+            "http.request.id": resolveRequestId(request),
+            "user_agent.original": request.headers.get("user-agent") ?? undefined,
+        });
+    }
+    if (signalLevel === "full") {
+        Object.assign(attrs, {
+            // FUTURE: "url.query"
+            "http.request.header.content-type": headerArr(request.headers, "content-type"),
+            "http.request.header.content-length": headerArr(request.headers, "content-length"),
+            // FUTURE: "client.address"
+        });
+    }
+    return attrs;
+};
+export const getResponseAttributes = (response, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const attrs = {
+        "http.response.status_code": response.status,
+    };
+    if (signalLevel === "full") {
+        Object.assign(attrs, {
+            "http.response.header.content-type": [headerArr(response.headers, "content-type")],
+            "http.response.header.content-length": [headerArr(response.headers, "content-length")],
+        });
+    }
+    return attrs;
+};

package/dist/telemetry/memory.d.ts

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

package/dist/telemetry/memory.js

@@ -0,0 +1,27 @@
+import { metrics } from "@opentelemetry/api";
+const meter = 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",
+});
+const isEnabled = (level) => level === "recommended" || level === "full";
+export const recordV8jsMemory = (level) => {
+    if (!isEnabled(level))
+        return;
+    let usage;
+    try {
+        usage = globalThis.process?.memoryUsage?.();
+    }
+    catch {
+        return;
+    }
+    if (!usage)
+        return;
+    heapUsedCounter.add(usage.heapUsed, defaultHeapSpaceAttrs);
+    heapSpacePhysicalSizeCounter.add(usage.rss, defaultHeapSpaceAttrs);
+};

package/dist/telemetry/span.d.ts

@@ -1,5 +1,8 @@
-import type { Attributes, Span, SpanOptions, Tracer } from "@opentelemetry/api";
-export declare const startSpan: (name: string, options?: SpanOptions, customTracer?: Tracer) => Span & {
+import type { Attributes, SpanOptions, Tracer } from "@opentelemetry/api";
+import type { TelemetrySignalLevel } from "../types";
+export declare const setSpanTracer: (tracer?: Tracer) => void;
+export declare const setSpanEventsEnabled: (level?: TelemetrySignalLevel) => void;
+export declare const startSpan: (name: string, options?: SpanOptions) => import("@opentelemetry/api").Span & {
     runWithContext: <T>(fn: () => Promise<T> | T) => T | Promise<T>;
     recordError: (_error: unknown) => void;
     finish: () => void;
@@ -7,4 +10,4 @@ export declare const startSpan: (name: string, options?: SpanOptions, customTrac
 };
 export declare const withSpan: <T>(name: string, run: () => Promise<T> | T, options?: SpanOptions) => Promise<T>;
 export declare const addSpanEvent: (name: string, attributes?: Attributes) => void;
-export declare const recordSpanError: (error: unknown) => void;
+export declare const setSpanAttributes: (attributes?: Attributes) => void;

package/dist/telemetry/span.js

@@ -1,51 +1,41 @@
 import { INVALID_SPAN_CONTEXT, SpanKind, SpanStatusCode, context, trace } from "@opentelemetry/api";
-const DEFAULT_TRACER_NAME = "@hebo-ai/gateway";
-const mem = () => process?.memoryUsage?.();
-const toError = (error) => (error instanceof Error ? error : new Error(String(error)));
-const maybeSetDynamicAttributes = (span, getAttributes) => {
-    const attrs = getAttributes();
-    if (Object.keys(attrs).length === 0)
-        return;
-    span.setAttributes(attrs);
-};
-const getMemoryAttributes = () => {
-    const memory = mem();
-    if (!memory)
-        return {};
-    return {
-        "process.memory.usage": memory.rss,
-        "process.memory.heap.used": memory.heapUsed,
-        "process.memory.heap.total": memory.heapTotal,
-    };
-};
+const DEFAULT_TRACER_NAME = "@hebo/gateway";
+let spanTracer;
+let spanEventsEnabled = false;
 const NOOP_SPAN = {
     runWithContext: (fn) => fn(),
     recordError: (_error) => { },
     finish: () => { },
     isExisting: true,
 };
-export const startSpan = (name, options, customTracer) => {
-    const tracer = customTracer ?? trace.getTracer(DEFAULT_TRACER_NAME);
-    const parentContext = context.active();
-    const activeSpan = trace.getActiveSpan();
-    const span = tracer.startSpan(name, { kind: activeSpan ? SpanKind.INTERNAL : SpanKind.SERVER, ...options }, parentContext);
-    if (!span.isRecording()) {
+export const setSpanTracer = (tracer) => {
+    spanTracer = tracer ?? trace.getTracer(DEFAULT_TRACER_NAME);
+};
+export const setSpanEventsEnabled = (level) => {
+    spanEventsEnabled = level === "recommended" || level === "full";
+};
+export const startSpan = (name, options) => {
+    if (!spanTracer) {
         return Object.assign(trace.wrapSpanContext(INVALID_SPAN_CONTEXT), NOOP_SPAN);
     }
-    maybeSetDynamicAttributes(span, getMemoryAttributes);
+    const parentContext = context.active();
+    const activeSpan = trace.getActiveSpan();
+    const span = spanTracer.startSpan(name, { kind: activeSpan ? SpanKind.INTERNAL : SpanKind.SERVER, ...options }, parentContext);
     const runWithContext = (fn) => context.with(trace.setSpan(parentContext, span), fn);
     const recordError = (error) => {
-        const err = toError(error);
+        const err = error instanceof Error ? error : new Error(String(error));
         span.recordException(err);
         span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
     };
     const finish = () => {
-        maybeSetDynamicAttributes(span, getMemoryAttributes);
         span.end();
     };
     return Object.assign(span, { runWithContext, recordError, finish, isExisting: !!activeSpan });
 };
 export const withSpan = async (name, run, options) => {
+    if (!spanTracer) {
+        return await run();
+    }
     const started = startSpan(name, options);
     try {
         return await started.runWithContext(run);
@@ -59,14 +49,12 @@ export const withSpan = async (name, run, options) => {
     }
 };
 export const addSpanEvent = (name, attributes) => {
-    const allAttributes = Object.assign(attributes ?? {}, getMemoryAttributes());
-    trace.getActiveSpan()?.addEvent(name, allAttributes);
+    if (!spanEventsEnabled)
+        return;
+    trace.getActiveSpan()?.addEvent(name, attributes);
 };
-export const recordSpanError = (error) => {
-    const span = trace.getActiveSpan();
-    if (!span)
+export const setSpanAttributes = (attributes) => {
+    if (!attributes)
         return;
-    const err = toError(error);
-    span.recordException(err);
-    span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+    trace.getActiveSpan()?.setAttributes(attributes);
 };

package/dist/telemetry/stream.d.ts

@@ -1,7 +1,3 @@
-export type InstrumentStreamHooks = {
-    onComplete?: (status: number, stats: {
-        bytes: number;
-    }) => void;
-    onError?: (error: unknown, status: number) => void;
-};
-export declare const instrumentStream: (src: ReadableStream<Uint8Array>, hooks: InstrumentStreamHooks, signal?: AbortSignal) => ReadableStream<Uint8Array>;
+export declare const wrapStream: (src: ReadableStream, hooks: {
+    onDone?: (status: number, reason: unknown) => void;
+}) => ReadableStream;

package/dist/telemetry/stream.js

@@ -1,43 +1,37 @@
-export const instrumentStream = (src, hooks, signal) => {
-    const stats = { bytes: 0 };
-    let done = false;
-    const finish = (status, reason) => {
-        if (done)
-            return;
-        done = true;
-        if (!reason)
-            reason = signal?.reason;
-        if (status >= 400) {
-            hooks.onError?.(reason, status);
+import { toOpenAIError } from "#/errors/openai";
+const isErrorChunk = (v) => v instanceof Error || !!v?.error;
+export const wrapStream = (src, hooks) => {
+    let finished = false;
+    const done = (reader, controller, status, reason) => {
+        if (!finished) {
+            finished = true;
+            hooks.onDone?.(status, reason);
         }
-        hooks.onComplete?.(status, stats);
+        reader.cancel(reason).catch(() => { });
+        controller.close();
     };
     return new ReadableStream({
         async start(controller) {
             const reader = src.getReader();
             try {
                 for (;;) {
-                    if (signal?.aborted) {
-                        finish(499, signal.reason);
-                        reader.cancel(signal.reason).catch(() => { });
-                        controller.close();
-                        return;
-                    }
                     // eslint-disable-next-line no-await-in-loop
-                    const { value, done } = await reader.read();
-                    if (done)
+                    const { value, done: eof } = await reader.read();
+                    if (eof)
                         break;
-                    stats.bytes += value.byteLength;
-                    controller.enqueue(value);
+                    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);
+                        return;
+                    }
                 }
-                finish(200);
-                controller.close();
+                done(reader, controller, 200);
             }
             catch (err) {
-                const status = signal?.aborted ? 499 : err?.name === "AbortError" ? 503 : 502;
-                finish(status, err);
-                reader.cancel(err).catch(() => { });
-                controller.close();
+                controller.enqueue(toOpenAIError(err));
+                done(reader, controller, 502, err);
             }
             finally {
                 try {
@@ -47,7 +41,10 @@ export const instrumentStream = (src, hooks, signal) => {
             }
         },
         cancel(reason) {
-            finish(499, reason);
+            if (!finished) {
+                finished = true;
+                hooks.onDone?.(499, reason);
+            }
             src.cancel(reason).catch(() => { });
         },
     });

package/dist/types.d.ts

@@ -3,7 +3,6 @@ import type { Tracer } from "@opentelemetry/api";
 import type { ChatCompletions, ChatCompletionsBody, ChatCompletionsChunk } from "./endpoints/chat-completions/schema";
 import type { Embeddings, EmbeddingsBody } from "./endpoints/embeddings/schema";
 import type { Model, ModelList } from "./endpoints/models";
-import type { OpenAIError } from "./errors/openai";
 import type { Logger, LoggerConfig } from "./logger";
 import type { ModelCatalog, ModelId } from "./models/types";
 import type { ProviderId, ProviderRegistry } from "./providers/types";
@@ -67,15 +66,11 @@ export type GatewayContext = {
     /**
      * Result returned by the handler (pre-response).
      */
-    result?: ChatCompletions | ReadableStream<ChatCompletionsChunk | OpenAIError> | Embeddings | Model | ModelList;
+    result?: ChatCompletions | ReadableStream<ChatCompletionsChunk | Error> | Embeddings | Model | ModelList;
     /**
      * Response object returned by the handler.
      */
     response?: Response;
-    /**
-     * Structured object result for streaming requests. Only available at the end of the stream.
-     */
-    streamResult?: ChatCompletions;
 };
 /**
  * Hook context: all fields readonly except `state`.
@@ -119,13 +114,14 @@ export type GatewayHooks = {
      * Runs after the endpoint handler.
      * @returns Result to replace, or undefined to keep original.
      */
-    after?: (ctx: AfterHookContext) => void | ChatCompletions | ReadableStream<ChatCompletionsChunk | OpenAIError> | Embeddings | Promise<void | ChatCompletions | ReadableStream<ChatCompletionsChunk | OpenAIError> | Embeddings>;
+    after?: (ctx: AfterHookContext) => void | ChatCompletions | ReadableStream<ChatCompletionsChunk | Error> | Embeddings | Promise<void | ChatCompletions | ReadableStream<ChatCompletionsChunk | Error> | Embeddings>;
     /**
      * Runs after the lifecycle has produced the final Response.
      * @returns Replacement Response, or undefined to keep original.
      */
     onResponse?: (ctx: OnResponseHookContext) => void | Response | Promise<void | Response>;
 };
+export type TelemetrySignalLevel = "off" | "required" | "recommended" | "full";
 /**
  * Main configuration object for the gateway.
  */
@@ -146,6 +142,10 @@ export type GatewayConfig = {
      * Optional lifecycle hooks for routing, auth, and response shaping.
      */
     hooks?: GatewayHooks;
+    /**
+     * Preferred logger configuration: custom logger or default logger settings.
+     */
+    logger?: Logger | LoggerConfig | null;
     /**
      * Optional AI SDK telemetry configuration.
      */
@@ -160,17 +160,18 @@ export type GatewayConfig = {
          */
         tracer?: Tracer;
         /**
-         * Controls how many telemetry attributes are attached to spans.
-         * - required: minimal safe baseline
+         * Telemetry signal levels by namespace.
+         * - off: disable the namespace
+         * - required: minimal baseline
          * - recommended: practical defaults
-         * - full: include all available attributes
+         * - full: include all available details
          */
-        attributes?: "required" | "recommended" | "full";
+        signals?: {
+            gen_ai?: TelemetrySignalLevel;
+            http?: TelemetrySignalLevel;
+            hebo?: TelemetrySignalLevel;
+        };
     };
-    /**
-     * Preferred logger configuration: custom logger or default logger settings.
-     */
-    logger?: Logger | LoggerConfig | null;
 };
 export declare const kParsed: unique symbol;
 export type GatewayConfigParsed = GatewayConfig & {

package/dist/utils/headers.d.ts

@@ -1,4 +1,4 @@
 export declare const REQUEST_ID_HEADER = "x-request-id";
-type HeaderSource = string | URL | Headers | Request | Response | RequestInit | ResponseInit | HeadersInit | undefined;
+type HeaderSource = Request | ResponseInit | undefined;
 export declare const resolveRequestId: (source: HeaderSource) => string | undefined;
 export {};

package/dist/utils/headers.js

@@ -1,18 +1,16 @@
 export const REQUEST_ID_HEADER = "x-request-id";
 export const resolveRequestId = (source) => {
-    if (!source || typeof source === "string" || source instanceof URL)
+    if (!source)
         return undefined;
-    if (source instanceof Request || source instanceof Response) {
+    if (source instanceof Request) {
         return source.headers.get(REQUEST_ID_HEADER) ?? undefined;
     }
-    const headers = "headers" in source ? source.headers : source;
-    if (!headers || typeof headers === "string")
+    const headers = source.headers;
+    if (!headers)
         return undefined;
-    if (Object.getPrototypeOf(headers) === Object.prototype) {
-        return headers[REQUEST_ID_HEADER] ?? undefined;
-    }
-    if (headers instanceof Headers)
+    if (headers instanceof Headers) {
         return headers.get(REQUEST_ID_HEADER) ?? undefined;
+    }
     if (Array.isArray(headers)) {
         for (const [key, value] of headers) {
             if (key.toLowerCase() === REQUEST_ID_HEADER)
@@ -20,5 +18,5 @@ export const resolveRequestId = (source) => {
         }
         return undefined;
     }
-    return undefined;
+    return headers[REQUEST_ID_HEADER];
 };

package/dist/utils/request.d.ts

@@ -1,8 +1,4 @@
 import type { RequestPatch } from "../types";
 export declare const prepareRequestHeaders: (request: Request) => Headers | undefined;
-export declare const prepareRequestBody: (request: Request) => Promise<{
-    body: ArrayBuffer | undefined;
-    requestBytes: number;
-}>;
 export declare const prepareForwardHeaders: (request: Request) => Record<string, string>;
 export declare const maybeApplyRequestPatch: (request: Request, patch: RequestPatch) => Request;

package/dist/utils/request.js

@@ -10,15 +10,6 @@ export const prepareRequestHeaders = (request) => {
     headers.set(REQUEST_ID_HEADER, requestId);
     return headers;
 };
-export const prepareRequestBody = async (request) => {
-    let requestBytes = 0;
-    let body;
-    if (request.body) {
-        body = await request.arrayBuffer();
-        requestBytes = body.byteLength;
-    }
-    return { body, requestBytes };
-};
 export const prepareForwardHeaders = (request) => {
     const userAgent = request.headers.get("user-agent");
     const appendedUserAgent = userAgent

package/dist/utils/response.js

@@ -13,7 +13,7 @@ class JsonToSseTransformStream extends TransformStream {
     }
 }
 export const prepareResponseInit = (request) => ({
-    headers: { [REQUEST_ID_HEADER]: resolveRequestId(request.headers) },
+    headers: { [REQUEST_ID_HEADER]: resolveRequestId(request) },
 });
 export const mergeResponseInit = (defaultHeaders, responseInit) => {
     const headers = new Headers(defaultHeaders);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.4.0-beta.3",
+  "version": "0.4.0",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
   "keywords": [
     "ai",
@@ -156,7 +156,6 @@
   "dependencies": {
     "@ai-sdk/provider": "^3.0.7",
     "@ai-sdk/provider-utils": "^4.0.13",
-    "@opentelemetry/api": "^1.9.0",
     "ai": "^6.0.67",
     "serialize-error": "^13.0.1",
     "zod": "^4.3.6"
@@ -169,7 +168,10 @@
     "@ai-sdk/groq": "^3.0.19",
     "@ai-sdk/openai": "^3.0.23",
     "@aws-sdk/credential-providers": "^3.981.0",
+    "@langfuse/otel": "^4.6.1",
     "@mjackson/node-fetch-server": "^0.7.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.5.1",
     "@opentelemetry/sdk-trace-base": "^2.5.1",
     "@tanstack/react-router": "^1.157.16",
     "@tanstack/react-start": "^1.157.16",
@@ -195,6 +197,7 @@
     "@ai-sdk/google-vertex": "^4.0.37",
     "@ai-sdk/groq": "^3.0.19",
     "@ai-sdk/openai": "^3.0.23",
+    "@opentelemetry/api": "^1.9.0",
     "typescript": "^5.9.3",
     "voyage-ai-provider": "^3.0.0"
   },