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

package/dist/telemetry/stream.d.ts

@@ -1,3 +1,3 @@
 export declare const wrapStream: (src: ReadableStream, hooks: {
     onDone?: (status: number, reason: unknown) => void;
-}, signal?: AbortSignal) => ReadableStream;
+}) => ReadableStream;

package/dist/telemetry/stream.js

@@ -1,43 +1,37 @@
-const isErrorChunk = (v) => !!v?.error;
-export const wrapStream = (src, hooks, signal) => {
-    let finishOnce = false;
-    const finish = (status, reason) => {
-        if (finishOnce)
-            return;
-        finishOnce = true;
-        hooks.onDone?.(status, reason ?? signal?.reason);
+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);
+        }
+        reader.cancel(reason).catch(() => { });
+        controller.close();
     };
     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) {
-                        close(499, signal.reason);
-                        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;
-                    controller.enqueue(value);
-                    if (isErrorChunk(value)) {
-                        const status = value.error.type === "invalid_request_error" ? 422 : 502;
-                        close(status, value.error.message);
+                    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;
-                close(status, err);
+                controller.enqueue(toOpenAIError(err));
+                done(reader, controller, 502, err);
             }
             finally {
                 try {
@@ -47,7 +41,10 @@ export const wrapStream = (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,7 +66,7 @@ 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.
      */
@@ -115,7 +114,7 @@ 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.4.0-beta.4",
+  "version": "0.4.1",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
   "keywords": [
     "ai",
@@ -168,6 +168,7 @@
     "@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",

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

@@ -405,11 +405,12 @@ export function toChatCompletionsResponse(
   return toResponse(toChatCompletions(result, model), responseInit);
 }
 
-export function toChatCompletionsStream(
+export function toChatCompletionsStream<E extends boolean = false>(
   result: StreamTextResult<ToolSet, Output.Output>,
   model: string,
-): ReadableStream<ChatCompletionsChunk | OpenAIError> {
-  return result.fullStream.pipeThrough(new ChatCompletionsStream(model));
+  wrapErrors?: E,
+): ReadableStream<ChatCompletionsChunk | (E extends true ? OpenAIError : Error)> {
+  return result.fullStream.pipeThrough(new ChatCompletionsStream(model, wrapErrors));
 }
 
 export function toChatCompletionsStreamResponse(
@@ -417,14 +418,14 @@ export function toChatCompletionsStreamResponse(
   model: string,
   responseInit?: ResponseInit,
 ): Response {
-  return toResponse(toChatCompletionsStream(result, model), responseInit);
+  return toResponse(toChatCompletionsStream(result, model, true), responseInit);
 }
 
-export class ChatCompletionsStream extends TransformStream<
+export class ChatCompletionsStream<E extends boolean = false> extends TransformStream<
   TextStreamPart<ToolSet>,
-  ChatCompletionsChunk | OpenAIError
+  ChatCompletionsChunk | (E extends true ? OpenAIError : Error)
 > {
-  constructor(model: string) {
+  constructor(model: string, wrapErrors?: E) {
     const streamId = `chatcmpl-${crypto.randomUUID()}`;
     const creationTime = Math.floor(Date.now() / 1000);
     let toolCallIndexCounter = 0;
@@ -535,9 +536,15 @@ export class ChatCompletionsStream extends TransformStream<
           }
 
           case "error": {
-            const error = part.error;
-            controller.enqueue(toOpenAIError(error));
-            controller.terminate();
+            let err: Error | OpenAIError;
+            if (wrapErrors) {
+              err = toOpenAIError(part.error);
+            } else if (part.error instanceof Error) {
+              err = part.error;
+            } else {
+              err = new Error(String(part.error));
+            }
+            controller.enqueue(err as E extends true ? OpenAIError : Error);
           }
         }
       },

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

@@ -23,7 +23,11 @@ import { winterCgHandler } from "../../lifecycle";
 import { logger } from "../../logger";
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { resolveProvider } from "../../providers/registry";
-import { recordRequestDuration, recordTokenUsage } from "../../telemetry/gen-ai";
+import {
+  recordRequestDuration,
+  recordTimePerOutputToken,
+  recordTokenUsage,
+} from "../../telemetry/gen-ai";
 import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
 import { resolveRequestId } from "../../utils/headers";
 import { prepareForwardHeaders } from "../../utils/request";
@@ -60,8 +64,8 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
 
     const parsed = ChatCompletionsBodySchema.safeParse(ctx.body);
     if (!parsed.success) {
-      // FUTURE: add body shape to error message
-      throw new GatewayError(z.prettifyError(parsed.error), 400);
+      // FUTURE: consider adding body shape to metadata
+      throw new GatewayError(z.prettifyError(parsed.error), 400, undefined, parsed.error);
     }
     ctx.body = parsed.data;
     addSpanEvent("hebo.request.parsed");
@@ -123,13 +127,12 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
       const result = streamText({
         model: languageModelWithMiddleware,
         headers: prepareForwardHeaders(ctx.request),
-        // No abort signal here, otherwise we can't detect upstream from client cancellations
-        // abortSignal: ctx.request.signal,
+        abortSignal: ctx.request.signal,
         timeout: {
           totalMs: 5 * 60 * 1000,
         },
         onAbort: () => {
-          throw new DOMException("Upstream failed", "AbortError");
+          throw new DOMException("The operation was aborted.", "AbortError");
         },
         onError: () => {},
         onFinish: (res) => {
@@ -143,7 +146,8 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
           const genAiResponseAttrs = getChatResponseAttributes(streamResult, genAiSignalLevel);
           setSpanAttributes(genAiResponseAttrs);
           recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-          recordRequestDuration(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
+          recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+          recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
         },
         experimental_include: {
           requestBody: false,
@@ -166,7 +170,6 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
     const result = await generateText({
       model: languageModelWithMiddleware,
       headers: prepareForwardHeaders(ctx.request),
-      // FUTURE: currently can't tell whether upstream or downstream abort
       abortSignal: ctx.request.signal,
       timeout: 5 * 60 * 1000,
       experimental_include: {
@@ -191,7 +194,8 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
       addSpanEvent("hebo.hooks.after.completed");
     }
 
-    recordRequestDuration(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
+    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+    recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
     return ctx.result;
   };
 

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

@@ -54,6 +54,11 @@ const toMessageParts = (message: ChatCompletionsMessage): Record<string, unknown
     return parts;
   }
 
+  // FUTURE: remove once Langfuse supports gen_ai.system_instructions
+  if (message.role === "system") {
+    return [toTextPart(message.content)];
+  }
+
   return [];
 };
 
@@ -103,11 +108,13 @@ export const getChatRequestAttributes = (
 
   if (signalLevel === "full") {
     Object.assign(attrs, {
-      "gen_ai.system_instructions": inputs.messages
-        .filter((m) => m.role === "system")
-        .map((m) => JSON.stringify({ parts: [toTextPart(m.content)] })),
+      // FUTURE: move system instructions from messages to here
+      // blocker: https://github.com/langfuse/langfuse/issues/11607
+      // "gen_ai.system_instructions": inputs.messages
+      //   .filter((m) => m.role === "system")
+      //   .map((m) => JSON.stringify(toTextPart(m.content))),
       "gen_ai.input.messages": inputs.messages
-        .filter((m) => m.role !== "system")
+        //.filter((m) => m.role !== "system")
         .map((m) => JSON.stringify({ role: m.role, parts: toMessageParts(m) })),
       "gen_ai.tool.definitions": JSON.stringify(inputs.tools),
     });

package/src/endpoints/embeddings/handler.ts

@@ -16,7 +16,11 @@ import { winterCgHandler } from "../../lifecycle";
 import { logger } from "../../logger";
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { resolveProvider } from "../../providers/registry";
-import { recordRequestDuration, recordTokenUsage } from "../../telemetry/gen-ai";
+import {
+  recordRequestDuration,
+  recordTimePerOutputToken,
+  recordTokenUsage,
+} from "../../telemetry/gen-ai";
 import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
 import { resolveRequestId } from "../../utils/headers";
 import { prepareForwardHeaders } from "../../utils/request";
@@ -53,8 +57,8 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
 
     const parsed = EmbeddingsBodySchema.safeParse(ctx.body);
     if (!parsed.success) {
-      // FUTURE: add body shape to error message
-      throw new GatewayError(z.prettifyError(parsed.error), 400);
+      // FUTURE: consider adding body shape to metadata
+      throw new GatewayError(z.prettifyError(parsed.error), 400, undefined, parsed.error);
     }
     ctx.body = parsed.data;
     addSpanEvent("hebo.request.parsed");
@@ -127,7 +131,8 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
       addSpanEvent("hebo.hooks.after.completed");
     }
 
-    recordRequestDuration(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
+    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+    recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
     return ctx.result;
   };
 

package/src/errors/gateway.ts

@@ -4,11 +4,12 @@ export class GatewayError extends Error {
   readonly status: number;
   readonly code: string;
 
-  constructor(error: string | Error, status: number, code?: string, cause?: unknown) {
-    const msg = typeof error === "string" ? error : error.message;
-    super(msg);
+  constructor(error: unknown, status: number, code?: string, cause?: unknown) {
+    const isError = error instanceof Error;
+    super(isError ? error.message : String(error));
+    this.cause = cause ?? (isError ? error : undefined);
+
     this.status = status;
     this.code = code ?? STATUS_CODE(status);
-    this.cause = cause ?? (typeof error === "string" ? undefined : error);
   }
 }

package/src/errors/openai.ts

@@ -25,7 +25,8 @@ export class OpenAIError {
 const mapType = (status: number) => (status < 500 ? "invalid_request_error" : "server_error");
 
 const maybeMaskMessage = (meta: ReturnType<typeof getErrorMeta>, requestId?: string) => {
-  if (!(isProduction() && (meta.status >= 500 || meta.code.includes("UPSTREAM")))) {
+  // FUTURE: consider masking all upstream errors, also 4xx
+  if (!(isProduction() && meta.status >= 500)) {
     return meta.message;
   }
   // FUTURE: always attach requestId to errors (masked and unmasked)

package/src/errors/utils.ts

@@ -11,6 +11,7 @@ export const STATUS_CODES = {
   409: "CONFLICT",
   422: "UNPROCESSABLE_ENTITY",
   429: "TOO_MANY_REQUESTS",
+  499: "CLIENT_CLOSED_REQUEST",
   500: "INTERNAL_SERVER_ERROR",
   502: "BAD_GATEWAY",
   503: "SERVICE_UNAVAILABLE",

package/src/lifecycle.ts

@@ -6,11 +6,13 @@ import type {
 } from "./types";
 
 import { parseConfig } from "./config";
+import { GatewayError } from "./errors/gateway";
 import { toOpenAIErrorResponse } from "./errors/openai";
 import { logger } from "./logger";
 import { getBaggageAttributes } from "./telemetry/baggage";
 import { initFetch } from "./telemetry/fetch";
 import { getRequestAttributes, getResponseAttributes } from "./telemetry/http";
+import { recordV8jsMemory } from "./telemetry/memory";
 import { addSpanEvent, setSpanEventsEnabled, setSpanTracer, startSpan } from "./telemetry/span";
 import { wrapStream } from "./telemetry/stream";
 import { resolveRequestId } from "./utils/headers";
@@ -23,7 +25,7 @@ export const winterCgHandler = (
 ) => {
   const parsedConfig = parseConfig(config);
 
-  if (parsedConfig.telemetry!.enabled) {
+  if (parsedConfig.telemetry?.enabled) {
     setSpanTracer(parsedConfig.telemetry?.tracer);
     setSpanEventsEnabled(parsedConfig.telemetry?.signals?.hebo);
     initFetch(parsedConfig.telemetry?.signals?.hebo);
@@ -58,18 +60,22 @@ export const winterCgHandler = (
         );
       }
 
-      const realStatus = status === 200 ? (ctx.response?.status ?? status) : status;
+      let realStatus = status;
+      if (ctx.request.signal.aborted) realStatus = 499;
+      else if (status === 200 && ctx.response?.status) realStatus = ctx.response.status;
+
       if (realStatus !== 200) {
-        // FUTURE: in-stream errors are redacted in prod
         (realStatus >= 500 ? logger.error : logger.warn)({
           requestId: resolveRequestId(ctx.request),
-          err: reason,
+          err: reason ?? ctx.request.signal.reason,
         });
 
         if (realStatus >= 500) span.recordError(reason);
       }
       span.setAttributes({ "http.response.status_code_effective": realStatus });
 
+      recordV8jsMemory(parsedConfig.telemetry?.signals?.hebo);
+
       span.finish();
     };
 
@@ -89,7 +95,7 @@ export const winterCgHandler = (
         ctx.result = (await span.runWithContext(() => run(ctx))) as typeof ctx.result;
 
         if (ctx.result instanceof ReadableStream) {
-          ctx.result = wrapStream(ctx.result, { onDone: finalize }, ctx.request.signal);
+          ctx.result = wrapStream(ctx.result, { onDone: finalize });
         }
 
         ctx.response = toResponse(ctx.result!, prepareResponseInit(ctx.request));
@@ -108,7 +114,12 @@ export const winterCgHandler = (
         finalize(ctx.response.status);
       }
     } catch (error) {
-      ctx.response = toOpenAIErrorResponse(error, prepareResponseInit(ctx.request));
+      ctx.response = toOpenAIErrorResponse(
+        ctx.request.signal.aborted
+          ? new GatewayError(error ?? ctx.request.signal.reason, 499)
+          : error,
+        prepareResponseInit(ctx.request),
+      );
       finalize(ctx.response.status, error);
     }
 

package/src/models/anthropic/presets.ts

@@ -65,6 +65,18 @@ export const claudeSonnet45 = presetFor<CanonicalModelId, CatalogModel>()(
   } satisfies DeepPartial<CatalogModel>,
 );
 
+export const claudeSonnet46 = presetFor<CanonicalModelId, CatalogModel>()(
+  "anthropic/claude-sonnet-4.6" as const,
+  {
+    ...CLAUDE_BASE,
+    ...CLAUDE_PDF_MODALITIES,
+    name: "Claude Sonnet 4.6",
+    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
+    created: "2026-02-17",
+    knowledge: "2025-08",
+  } satisfies DeepPartial<CatalogModel>,
+);
+
 export const claudeSonnet4 = presetFor<CanonicalModelId, CatalogModel>()(
   "anthropic/claude-sonnet-4" as const,
   {
@@ -149,7 +161,7 @@ export const claudeOpus4 = presetFor<CanonicalModelId, CatalogModel>()(
 );
 
 const claudeAtomic = {
-  "v4.6": [claudeOpus46],
+  "v4.6": [claudeSonnet46, claudeOpus46],
   "v4.5": [claudeHaiku45, claudeSonnet45, claudeOpus45],
   "v4.1": [claudeOpus41],
   v4: [claudeSonnet4, claudeOpus4],
@@ -157,7 +169,7 @@ const claudeAtomic = {
   "v3.5": [claudeSonnet35, claudeHaiku35],
   v3: [claudeHaiku3],
   haiku: [claudeHaiku45, claudeHaiku35, claudeHaiku3],
-  sonnet: [claudeSonnet45, claudeSonnet4, claudeSonnet37, claudeSonnet35],
+  sonnet: [claudeSonnet46, claudeSonnet45, claudeSonnet4, claudeSonnet37, claudeSonnet35],
   opus: [claudeOpus46, claudeOpus45, claudeOpus41, claudeOpus4],
 } as const;
 

package/src/models/types.ts

@@ -3,6 +3,7 @@ import type { ProviderId } from "../providers/types";
 export const CANONICAL_MODEL_IDS = [
   // Anthropic
   "anthropic/claude-opus-4.6",
+  "anthropic/claude-sonnet-4.6",
   "anthropic/claude-haiku-4.5",
   "anthropic/claude-sonnet-4.5",
   "anthropic/claude-opus-4.5",

package/src/providers/bedrock/canonical.ts

@@ -13,6 +13,7 @@ import { withCanonicalIds } from "../registry";
 const MAPPING = {
   // Require Inference Profiles and can't be resolved from standard name mapping
   "anthropic/claude-haiku-4.5": "{ip}anthropic.claude-haiku-4-5-20251001-v1:0",
+  "anthropic/claude-sonnet-4.6": "{ip}anthropic.claude-sonnet-4-6",
   "anthropic/claude-sonnet-4.5": "{ip}anthropic.claude-sonnet-4-5-20250929-v1:0",
   "anthropic/claude-opus-4.6": "{ip}anthropic.claude-opus-4-6-v1",
   "anthropic/claude-opus-4.5": "{ip}anthropic.claude-opus-4-5-20251101-v1:0",

package/src/telemetry/gen-ai.ts

@@ -2,7 +2,7 @@ import { metrics, type Attributes } from "@opentelemetry/api";
 
 import type { TelemetrySignalLevel } from "../types";
 
-const meter = metrics.getMeter("@hebo-ai/gateway");
+const meter = metrics.getMeter("@hebo/gateway");
 
 const requestDurationHistogram = meter.createHistogram("gen_ai.server.request.duration", {
   description: "End-to-end gateway request duration",
@@ -14,6 +14,16 @@ const requestDurationHistogram = meter.createHistogram("gen_ai.server.request.du
   },
 });
 
+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}",
@@ -27,13 +37,31 @@ const tokenUsageHistogram = meter.createHistogram("gen_ai.client.token.usage", {
 
 // FUTURE: record unsuccessful calls
 export const recordRequestDuration = (
-  duration: number,
+  start: number,
   attrs: Attributes,
   signalLevel?: TelemetrySignalLevel,
 ) => {
   if (!signalLevel || signalLevel === "off") return;
 
-  requestDurationHistogram.record(duration / 1000, attrs);
+  requestDurationHistogram.record((performance.now() - start) / 1000, attrs);
+};
+
+// FUTURE: record unsuccessful calls
+export const recordTimePerOutputToken = (
+  start: number,
+  tokenAttrs: Attributes,
+  metricAttrs: Attributes,
+  signalLevel?: TelemetrySignalLevel,
+) => {
+  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

package/src/telemetry/memory.ts

@@ -0,0 +1,36 @@
+import { metrics } from "@opentelemetry/api";
+
+import type { TelemetrySignalLevel } from "../types";
+
+const meter = metrics.getMeter("@hebo/gateway");
+const defaultHeapSpaceAttrs = { "v8js.heap.space.name": "total" } as const;
+
+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?: TelemetrySignalLevel) => level === "recommended" || level === "full";
+
+export const recordV8jsMemory = (level?: TelemetrySignalLevel) => {
+  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/src/telemetry/span.ts

@@ -4,7 +4,7 @@ import { INVALID_SPAN_CONTEXT, SpanKind, SpanStatusCode, context, trace } from "
 
 import type { TelemetrySignalLevel } from "../types";
 
-const DEFAULT_TRACER_NAME = "@hebo-ai/gateway";
+const DEFAULT_TRACER_NAME = "@hebo/gateway";
 
 let spanTracer: Tracer | undefined;
 let spanEventsEnabled = false;