@hebo-ai/gateway 0.4.0-beta.2 → 0.4.0-beta.4

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,4 @@
+import { type Attributes } from "@opentelemetry/api";
+import type { TelemetrySignalLevel } from "../types";
+export declare const recordRequestDuration: (duration: number, attrs: Attributes, signalLevel?: TelemetrySignalLevel) => void;
+export declare const recordTokenUsage: (tokenAttrs: Attributes, metricAttrs: Attributes, signalLevel?: TelemetrySignalLevel) => void;

package/dist/telemetry/gen-ai.js

@@ -0,0 +1,42 @@
+import { metrics } from "@opentelemetry/api";
+const meter = metrics.getMeter("@hebo-ai/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 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 = (duration, attrs, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return;
+    requestDurationHistogram.record(duration / 1000, attrs);
+};
+// 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/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,
-    };
-};
+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;
+}, signal?: AbortSignal) => ReadableStream;

package/dist/telemetry/stream.js

@@ -1,43 +1,43 @@
-export const instrumentStream = (src, hooks, signal) => {
-    const stats = { bytes: 0 };
-    let done = false;
+const isErrorChunk = (v) => !!v?.error;
+export const wrapStream = (src, hooks, signal) => {
+    let finishOnce = false;
     const finish = (status, reason) => {
-        if (done)
+        if (finishOnce)
             return;
-        done = true;
-        if (!reason)
-            reason = signal?.reason;
-        if (status >= 400) {
-            hooks.onError?.(reason, status);
-        }
-        hooks.onComplete?.(status, stats);
+        finishOnce = true;
+        hooks.onDone?.(status, reason ?? signal?.reason);
     };
     return new ReadableStream({
         async start(controller) {
             const reader = src.getReader();
+            const close = (status, reason) => {
+                finish(status, reason);
+                reader.cancel(reason).catch(() => { });
+                controller.close();
+            };
             try {
                 for (;;) {
                     if (signal?.aborted) {
-                        finish(499, signal.reason);
-                        reader.cancel(signal.reason).catch(() => { });
-                        controller.close();
+                        close(499, signal.reason);
                         return;
                     }
                     // eslint-disable-next-line no-await-in-loop
                     const { value, done } = await reader.read();
                     if (done)
                         break;
-                    stats.bytes += value.byteLength;
                     controller.enqueue(value);
+                    if (isErrorChunk(value)) {
+                        const status = value.error.type === "invalid_request_error" ? 422 : 502;
+                        close(status, value.error.message);
+                        return;
+                    }
                 }
                 finish(200);
                 controller.close();
             }
             catch (err) {
                 const status = signal?.aborted ? 499 : err?.name === "AbortError" ? 503 : 502;
-                finish(status, err);
-                reader.cancel(err).catch(() => { });
-                controller.close();
+                close(status, err);
             }
             finally {
                 try {

package/dist/types.d.ts

@@ -72,10 +72,6 @@ export type GatewayContext = {
      * 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`.
@@ -126,6 +122,7 @@ export type GatewayHooks = {
      */
     onResponse?: (ctx: OnResponseHookContext) => void | Response | Promise<void | Response>;
 };
+export type TelemetrySignalLevel = "off" | "required" | "recommended" | "full";
 /**
  * Main configuration object for the gateway.
  */
@@ -146,6 +143,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 +161,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.2",
+  "version": "0.4.0-beta.4",
   "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"
@@ -170,6 +169,8 @@
     "@ai-sdk/openai": "^3.0.23",
     "@aws-sdk/credential-providers": "^3.981.0",
     "@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 +196,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"
   },

package/src/config.ts

@@ -1,16 +1,21 @@
 import { isLogger, logger, setLoggerInstance } from "./logger";
 import { createDefaultLogger } from "./logger/default";
-import { kParsed, type GatewayConfig, type GatewayConfigParsed } from "./types";
+import {
+  kParsed,
+  type GatewayConfig,
+  type GatewayConfigParsed,
+  type TelemetrySignalLevel,
+} from "./types";
 
 export const parseConfig = (config: GatewayConfig): GatewayConfigParsed => {
-  // If it has been parsed before, just return
+  // If it has been parsed before, just return.
   if (kParsed in config) return config as GatewayConfigParsed;
 
   const providers = config.providers ?? {};
   const parsedProviders = {} as typeof providers;
   const models = config.models ?? {};
 
-  // Set the global logger instance
+  // Set the global logger instance.
   if (config.logger === undefined) {
     setLoggerInstance(createDefaultLogger({}));
   } else if (config.logger !== null) {
@@ -23,7 +28,7 @@ export const parseConfig = (config: GatewayConfig): GatewayConfigParsed => {
     );
   }
 
-  // Strip providers that are not configured
+  // Strip providers that are not configured.
   for (const id in providers) {
     const provider = providers[id];
     if (provider === undefined) {
@@ -37,7 +42,7 @@ export const parseConfig = (config: GatewayConfig): GatewayConfigParsed => {
     throw new Error("No providers configured (config.providers is empty)");
   }
 
-  // Strip providers that are not configured from models
+  // Strip providers that are not configured from models.
   const parsedModels = {} as typeof models;
   const warnings = new Set<string>();
   for (const id in models) {
@@ -60,12 +65,28 @@ export const parseConfig = (config: GatewayConfig): GatewayConfigParsed => {
     throw new Error("No models configured (config.models is empty)");
   }
 
+  // Default for the telemetry settings.
+  const telemetryEnabled = config.telemetry?.enabled ?? false;
+  const telemetrySignals: Record<"http" | "gen_ai" | "hebo", TelemetrySignalLevel> =
+    telemetryEnabled
+      ? {
+          http: config.telemetry?.signals?.http ?? "recommended",
+          gen_ai: config.telemetry?.signals?.gen_ai ?? "full",
+          hebo: config.telemetry?.signals?.hebo ?? "off",
+        }
+      : {
+          http: "off",
+          gen_ai: "off",
+          hebo: "off",
+        };
+
+  // Return parsed config.
   return {
     ...config,
-    logger: config.logger,
     telemetry: {
       ...config.telemetry,
-      enabled: config.telemetry?.enabled ?? false,
+      enabled: telemetryEnabled,
+      signals: telemetrySignals,
     },
     providers: parsedProviders,
     models: parsedModels,

package/src/endpoints/chat-completions/converters.ts

@@ -185,6 +185,7 @@ export function fromChatCompletionsAssistantMessage(
 
     if (tool_calls?.length) {
       for (const tc of tool_calls) {
+        // eslint-disable-next-line no-shadow
         const { id, function: fn, extra_content } = tc;
         const out: ToolCallPart = {
           type: "tool-call",
@@ -535,9 +536,8 @@ export class ChatCompletionsStream extends TransformStream<
 
           case "error": {
             const error = part.error;
-            // FUTURE mask in production mode and return responseID
             controller.enqueue(toOpenAIError(error));
-            break;
+            controller.terminate();
           }
         }
       },