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

package/README.md

@@ -19,6 +19,7 @@ Learn more in our blog post: [Yet Another AI Gateway?](https://hebo.ai/blog/2601
 - 🗂️ Model catalog with extensible metadata capabilities.
 - 🪝 Hook system to customize routing, auth, rate limits, and shape responses.
 - 🧰 Low-level OpenAI-compatible schema, converters, and middleware helpers.
+- 👁️ OpenTelemetry support for GenAI semantic conventions (Langfuse-compatible).
 
 ## 📦 Installation
 
@@ -615,12 +616,20 @@ const gw = gateway({
   telemetry: {
     // default: false
     enabled: true,
-    // default: TraceProivder from @opentelemetry/api singleton
+    // default: TraceProvider from @opentelemetry/api singleton
     tracer: trace.getTracer("my-gateway"),
-    // "required" = minimal baseline attributes
-    // "recommended" = practical operational attributes (request/response metadata, genai model/usage fields)
-    // "full" = also include body fields (e.g. genai input/output messages)
-    attributes: "full",
+    // Telemetry levels by namespace:
+    // "off" | "required" | "recommended" | "full"
+    signals: {
+      // gen_ai.* semantic attributes
+      gen_ai: "full",
+      // http.*, url.*, server.* semantic attributes
+      http: "recommended",
+      // hebo-specific telemetry:
+      // - recommended: hebo.* span events
+      // - full: hebo.* span events + fetch instrumentation
+      hebo: "recommended",
+    },
   },
 });
 ```
@@ -633,6 +642,32 @@ https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
 
 For observability integration that is not otel compliant, you can disable built-in telemetry and manually instrument requests during `before` / `after` hooks.
 
+#### Langfuse
+
+Hebo telemetry spans are OpenTelemetry-compatible, so you can send them to Langfuse via `@langfuse/otel`.
+
+```ts
+import { gateway } from "@hebo-ai/gateway";
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import { context } from "@opentelemetry/api";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
+
+context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
+
+const gw = gateway({
+  // ...
+  telemetry: {
+    enabled: true,
+    tracer = new BasicTracerProvider({
+      spanProcessors: [new LangfuseSpanProcessor()],
+    }).getTracer("hebo");,
+  },
+});
+```
+
+Langfuse credentials are read from environment variables by the Langfuse OTel SDK (`LANGFUSE_PUBLIC_KEY`, `LANGFUSE_SECRET_KEY`, `LANGFUSE_BASE_URL`).
+
 ### Passing Framework State to Hooks
 
 You can pass per-request info from your framework into the gateway via the second `state` argument on the handler, then read it in hooks through `ctx.state`.

package/dist/config.js

@@ -1,14 +1,14 @@
 import { isLogger, logger, setLoggerInstance } from "./logger";
 import { createDefaultLogger } from "./logger/default";
-import { kParsed } from "./types";
+import { kParsed, } from "./types";
 export const parseConfig = (config) => {
-    // If it has been parsed before, just return
+    // If it has been parsed before, just return.
     if (kParsed in config)
         return config;
     const providers = config.providers ?? {};
     const parsedProviders = {};
     const models = config.models ?? {};
-    // Set the global logger instance
+    // Set the global logger instance.
     if (config.logger === undefined) {
         setLoggerInstance(createDefaultLogger({}));
     }
@@ -18,7 +18,7 @@ export const parseConfig = (config) => {
             ? `[logger] custom logger configured`
             : `[logger] logger configured: level=${config.logger.level}`);
     }
-    // Strip providers that are not configured
+    // Strip providers that are not configured.
     for (const id in providers) {
         const provider = providers[id];
         if (provider === undefined) {
@@ -30,7 +30,7 @@ export const parseConfig = (config) => {
     if (Object.keys(parsedProviders).length === 0) {
         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 = {};
     const warnings = new Set();
     for (const id in models) {
@@ -51,12 +51,26 @@ export const parseConfig = (config) => {
     if (Object.keys(parsedModels).length === 0) {
         throw new Error("No models configured (config.models is empty)");
     }
+    // Default for the telemetry settings.
+    const telemetryEnabled = config.telemetry?.enabled ?? false;
+    const telemetrySignals = 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/dist/endpoints/chat-completions/converters.d.ts

@@ -25,10 +25,10 @@ export declare const convertToToolSet: (tools: ChatCompletionsTool[] | undefined
 export declare const convertToToolChoice: (toolChoice: ChatCompletionsToolChoice | undefined) => ToolChoice<ToolSet> | undefined;
 export declare function toChatCompletions(result: GenerateTextResult<ToolSet, Output.Output>, model: string): ChatCompletions;
 export declare function toChatCompletionsResponse(result: GenerateTextResult<ToolSet, Output.Output>, model: string, responseInit?: ResponseInit): Response;
-export declare function toChatCompletionsStream(result: StreamTextResult<ToolSet, Output.Output>, model: string): ReadableStream<ChatCompletionsChunk | OpenAIError>;
+export declare function toChatCompletionsStream<E extends boolean = false>(result: StreamTextResult<ToolSet, Output.Output>, model: string, wrapErrors?: E): ReadableStream<ChatCompletionsChunk | (E extends true ? OpenAIError : Error)>;
 export declare function toChatCompletionsStreamResponse(result: StreamTextResult<ToolSet, Output.Output>, model: string, responseInit?: ResponseInit): Response;
-export declare class ChatCompletionsStream extends TransformStream<TextStreamPart<ToolSet>, ChatCompletionsChunk | OpenAIError> {
-    constructor(model: string);
+export declare class ChatCompletionsStream<E extends boolean = false> extends TransformStream<TextStreamPart<ToolSet>, ChatCompletionsChunk | (E extends true ? OpenAIError : Error)> {
+    constructor(model: string, wrapErrors?: E);
 }
 export declare const toChatCompletionsAssistantMessage: (result: GenerateTextResult<ToolSet, Output.Output>) => ChatCompletionsAssistantMessage;
 export declare function toReasoningDetail(reasoning: ReasoningOutput, id: string, index: number): ChatCompletionsReasoningDetail;

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

@@ -94,6 +94,7 @@ export function fromChatCompletionsAssistantMessage(message) {
         }
         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 = {
                     type: "tool-call",
@@ -274,14 +275,14 @@ export function toChatCompletions(result, model) {
 export function toChatCompletionsResponse(result, model, responseInit) {
     return toResponse(toChatCompletions(result, model), responseInit);
 }
-export function toChatCompletionsStream(result, model) {
-    return result.fullStream.pipeThrough(new ChatCompletionsStream(model));
+export function toChatCompletionsStream(result, model, wrapErrors) {
+    return result.fullStream.pipeThrough(new ChatCompletionsStream(model, wrapErrors));
 }
 export function toChatCompletionsStreamResponse(result, model, responseInit) {
-    return toResponse(toChatCompletionsStream(result, model), responseInit);
+    return toResponse(toChatCompletionsStream(result, model, true), responseInit);
 }
 export class ChatCompletionsStream extends TransformStream {
-    constructor(model) {
+    constructor(model, wrapErrors) {
         const streamId = `chatcmpl-${crypto.randomUUID()}`;
         const creationTime = Math.floor(Date.now() / 1000);
         let toolCallIndexCounter = 0;
@@ -347,10 +348,17 @@ export class ChatCompletionsStream extends TransformStream {
                         break;
                     }
                     case "error": {
-                        const error = part.error;
-                        // FUTURE mask in production mode and return responseID
-                        controller.enqueue(toOpenAIError(error));
-                        break;
+                        let err;
+                        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);
                     }
                 }
             },

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

@@ -5,14 +5,18 @@ import { winterCgHandler } from "../../lifecycle";
 import { logger } from "../../logger";
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { resolveProvider } from "../../providers/registry";
-import { addSpanEvent } from "../../telemetry/span";
+import { recordRequestDuration, recordTimePerOutputToken, recordTokenUsage, } from "../../telemetry/gen-ai";
+import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
 import { resolveRequestId } from "../../utils/headers";
 import { prepareForwardHeaders } from "../../utils/request";
 import { convertToTextCallOptions, toChatCompletions, toChatCompletionsStream } from "./converters";
+import { getChatGeneralAttributes, getChatRequestAttributes, getChatResponseAttributes, } from "./otel";
 import { ChatCompletionsBodySchema } from "./schema";
 export const chatCompletions = (config) => {
     const hooks = config.hooks;
     const handler = async (ctx) => {
+        const start = performance.now();
+        ctx.operation = "chat";
         addSpanEvent("hebo.handler.started");
         // Guard: enforce HTTP method early.
         if (!ctx.request || ctx.request.method !== "POST") {
@@ -29,11 +33,11 @@ export const chatCompletions = (config) => {
         addSpanEvent("hebo.request.deserialized");
         const parsed = ChatCompletionsBodySchema.safeParse(ctx.body);
         if (!parsed.success) {
-            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");
-        ctx.operation = "chat";
         if (hooks?.before) {
             ctx.body = (await hooks.before(ctx)) ?? ctx.body;
             addSpanEvent("hebo.hooks.before.completed");
@@ -44,10 +48,7 @@ export const chatCompletions = (config) => {
         ctx.resolvedModelId =
             (await hooks?.resolveModelId?.(ctx)) ?? ctx.modelId;
         logger.debug(`[chat] resolved ${ctx.modelId} to ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.model.resolved", {
-            "gen_ai.request.model": ctx.modelId ?? "",
-            "gen_ai.response.model": ctx.resolvedModelId ?? "",
-        });
+        addSpanEvent("hebo.model.resolved");
         const override = await hooks?.resolveProvider?.(ctx);
         ctx.provider =
             override ??
@@ -60,7 +61,10 @@ export const chatCompletions = (config) => {
         const languageModel = ctx.provider.languageModel(ctx.resolvedModelId);
         ctx.resolvedProviderId = languageModel.provider;
         logger.debug(`[chat] using ${languageModel.provider} for ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.provider.resolved", { "gen_ai.provider.name": ctx.resolvedProviderId });
+        addSpanEvent("hebo.provider.resolved");
+        const genAiSignalLevel = config.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getChatGeneralAttributes(ctx, genAiSignalLevel);
+        setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
         const textOptions = convertToTextCallOptions(inputs);
         logger.trace({
@@ -68,6 +72,7 @@ export const chatCompletions = (config) => {
             options: textOptions,
         }, "[chat] AI SDK options");
         addSpanEvent("hebo.options.prepared");
+        setSpanAttributes(getChatRequestAttributes(inputs, genAiSignalLevel));
         // Build middleware chain (model -> forward params -> provider).
         const languageModelWithMiddleware = wrapLanguageModel({
             model: languageModel,
@@ -79,24 +84,23 @@ export const chatCompletions = (config) => {
             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,
-                onError: ({ error }) => {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    logger.error({
-                        requestId,
-                        err,
-                    });
-                    throw error;
+                abortSignal: ctx.request.signal,
+                timeout: {
+                    totalMs: 5 * 60 * 1000,
                 },
                 onAbort: () => {
-                    throw new DOMException("Upstream failed", "AbortError");
+                    throw new DOMException("The operation was aborted.", "AbortError");
                 },
-                onFinish: (result) => {
-                    ctx.streamResult = toChatCompletions(result, ctx.resolvedModelId);
-                },
-                timeout: {
-                    totalMs: 5 * 60 * 1000,
+                onError: () => { },
+                onFinish: (res) => {
+                    addSpanEvent("hebo.ai-sdk.completed");
+                    const streamResult = toChatCompletions(res, ctx.resolvedModelId);
+                    addSpanEvent("hebo.result.transformed");
+                    const genAiResponseAttrs = getChatResponseAttributes(streamResult, genAiSignalLevel);
+                    setSpanAttributes(genAiResponseAttrs);
+                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+                    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+                    recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
                 },
                 experimental_include: {
                     requestBody: false,
@@ -104,9 +108,7 @@ export const chatCompletions = (config) => {
                 includeRawChunks: false,
                 ...textOptions,
             });
-            addSpanEvent("hebo.ai-sdk.completed");
             ctx.result = toChatCompletionsStream(result, ctx.resolvedModelId);
-            addSpanEvent("hebo.result.transformed");
             if (hooks?.after) {
                 ctx.result = (await hooks.after(ctx)) ?? ctx.result;
                 addSpanEvent("hebo.hooks.after.completed");
@@ -117,23 +119,28 @@ export const chatCompletions = (config) => {
         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: {
                 requestBody: false,
                 responseBody: false,
             },
-            timeout: 5 * 60 * 1000,
             ...textOptions,
         });
         logger.trace({ requestId, result }, "[chat] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
+        // Transform result.
         ctx.result = toChatCompletions(result, ctx.resolvedModelId);
         addSpanEvent("hebo.result.transformed");
+        const genAiResponseAttrs = getChatResponseAttributes(ctx.result, genAiSignalLevel);
+        setSpanAttributes(genAiResponseAttrs);
+        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
         if (hooks?.after) {
             ctx.result = (await hooks.after(ctx)) ?? ctx.result;
             addSpanEvent("hebo.hooks.after.completed");
         }
+        recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
         return ctx.result;
     };
     return { handler: winterCgHandler(handler, config) };

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

@@ -0,0 +1,6 @@
+import type { Attributes } from "@opentelemetry/api";
+import type { ChatCompletions, ChatCompletionsBody } from "./schema";
+import { type GatewayContext, type TelemetrySignalLevel } from "../../types";
+export declare const getChatGeneralAttributes: (ctx: GatewayContext, signalLevel?: TelemetrySignalLevel) => Attributes;
+export declare const getChatRequestAttributes: (inputs: ChatCompletionsBody, signalLevel?: TelemetrySignalLevel) => Attributes;
+export declare const getChatResponseAttributes: (completions: ChatCompletions, signalLevel?: TelemetrySignalLevel) => Attributes;

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

@@ -0,0 +1,127 @@
+import {} from "../../types";
+const toTextPart = (content) => ({ type: "text", content });
+const toMessageParts = (message) => {
+    if (message.role === "assistant") {
+        const parts = [];
+        if (typeof message.content === "string")
+            parts.push(toTextPart(message.content));
+        if (Array.isArray(message.tool_calls)) {
+            for (const call of message.tool_calls) {
+                parts.push({
+                    type: "tool_call",
+                    id: call.id,
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                });
+            }
+        }
+        return parts;
+    }
+    if (message.role === "tool") {
+        return [{ type: "tool_call_response", id: message.tool_call_id, content: message.content }];
+    }
+    if (message.role === "user") {
+        const parts = [];
+        if (typeof message.content === "string")
+            parts.push(toTextPart(message.content));
+        if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (part.type === "text") {
+                    parts.push(toTextPart(part.text));
+                }
+                else if (part.type === "image_url") {
+                    parts.push({ type: "image", content: part.image_url.url });
+                }
+                else {
+                    parts.push({
+                        type: "file",
+                        // FUTURE: optionally expose safe metadata without raw binary payloads.
+                        content: part.file.filename ?? "[REDACTED_BINARY_DATA]",
+                        media_type: part.file.media_type,
+                    });
+                }
+            }
+        }
+        return parts;
+    }
+    // FUTURE: remove once Langfuse supports gen_ai.system_instructions
+    if (message.role === "system") {
+        return [toTextPart(message.content)];
+    }
+    return [];
+};
+export const getChatGeneralAttributes = (ctx, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const requestModel = typeof ctx.body?.model === "string" ? ctx.body.model : ctx.modelId;
+    return {
+        "gen_ai.operation.name": ctx.operation,
+        "gen_ai.request.model": requestModel,
+        "gen_ai.response.model": ctx.resolvedModelId,
+        "gen_ai.provider.name": ctx.resolvedProviderId,
+    };
+};
+export const getChatRequestAttributes = (inputs, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const attrs = {};
+    if (inputs.seed !== undefined) {
+        Object.assign(attrs, { "gen_ai.request.seed": inputs.seed });
+    }
+    if (signalLevel !== "required") {
+        Object.assign(attrs, {
+            "gen_ai.request.stream": inputs.stream,
+            "gen_ai.request.frequency_penalty": inputs.frequency_penalty,
+            "gen_ai.request.max_tokens": inputs.max_completion_tokens,
+            "gen_ai.request.presence_penalty": inputs.presence_penalty,
+            "gen_ai.request.stop_sequences": inputs.stop
+                ? Array.isArray(inputs.stop)
+                    ? inputs.stop
+                    : [inputs.stop]
+                : undefined,
+            "gen_ai.request.temperature": inputs.temperature,
+            "gen_ai.request.top_p": inputs.top_p,
+        });
+    }
+    if (signalLevel === "full") {
+        Object.assign(attrs, {
+            // 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")
+                .map((m) => JSON.stringify({ role: m.role, parts: toMessageParts(m) })),
+            "gen_ai.tool.definitions": JSON.stringify(inputs.tools),
+        });
+    }
+    return attrs;
+};
+export const getChatResponseAttributes = (completions, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const attrs = {
+        "gen_ai.response.id": completions.id,
+    };
+    if (signalLevel !== "required") {
+        Object.assign(attrs, {
+            "gen_ai.response.finish_reasons": completions.choices?.map((c) => c.finish_reason),
+            "gen_ai.usage.total_tokens": completions.usage?.total_tokens,
+            "gen_ai.usage.input_tokens": completions.usage?.prompt_tokens,
+            "gen_ai.usage.cached_tokens": completions.usage?.prompt_tokens_details?.cached_tokens,
+            "gen_ai.usage.output_tokens": completions.usage?.completion_tokens,
+            "gen_ai.usage.reasoning_tokens": completions.usage?.completion_tokens_details?.reasoning_tokens,
+        });
+    }
+    if (signalLevel === "full") {
+        Object.assign(attrs, {
+            "gen_ai.output.messages": completions.choices?.map((c) => JSON.stringify({
+                role: c.message.role,
+                parts: toMessageParts(c.message),
+                finish_reason: c.finish_reason,
+            })),
+        });
+    }
+    return attrs;
+};

package/dist/endpoints/embeddings/handler.js

@@ -5,14 +5,18 @@ import { winterCgHandler } from "../../lifecycle";
 import { logger } from "../../logger";
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { resolveProvider } from "../../providers/registry";
-import { addSpanEvent } from "../../telemetry/span";
+import { recordRequestDuration, recordTimePerOutputToken, recordTokenUsage, } from "../../telemetry/gen-ai";
+import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
 import { resolveRequestId } from "../../utils/headers";
 import { prepareForwardHeaders } from "../../utils/request";
 import { convertToEmbedCallOptions, toEmbeddings } from "./converters";
+import { getEmbeddingsGeneralAttributes, getEmbeddingsRequestAttributes, getEmbeddingsResponseAttributes, } from "./otel";
 import { EmbeddingsBodySchema } from "./schema";
 export const embeddings = (config) => {
     const hooks = config.hooks;
     const handler = async (ctx) => {
+        const start = performance.now();
+        ctx.operation = "embeddings";
         addSpanEvent("hebo.handler.started");
         // Guard: enforce HTTP method early.
         if (!ctx.request || ctx.request.method !== "POST") {
@@ -29,11 +33,11 @@ export const embeddings = (config) => {
         addSpanEvent("hebo.request.deserialized");
         const parsed = EmbeddingsBodySchema.safeParse(ctx.body);
         if (!parsed.success) {
-            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");
-        ctx.operation = "embeddings";
         if (hooks?.before) {
             ctx.body = (await hooks.before(ctx)) ?? ctx.body;
             addSpanEvent("hebo.hooks.before.completed");
@@ -44,10 +48,7 @@ export const embeddings = (config) => {
         ctx.resolvedModelId =
             (await hooks?.resolveModelId?.(ctx)) ?? ctx.modelId;
         logger.debug(`[embeddings] resolved ${ctx.modelId} to ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.model.resolved", {
-            "gen_ai.request.model": ctx.modelId ?? "",
-            "gen_ai.response.model": ctx.resolvedModelId ?? "",
-        });
+        addSpanEvent("hebo.model.resolved");
         const override = await hooks?.resolveProvider?.(ctx);
         ctx.provider =
             override ??
@@ -60,13 +61,15 @@ export const embeddings = (config) => {
         const embeddingModel = ctx.provider.embeddingModel(ctx.resolvedModelId);
         ctx.resolvedProviderId = embeddingModel.provider;
         logger.debug(`[embeddings] using ${embeddingModel.provider} for ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.provider.resolved", {
-            "gen_ai.provider.name": ctx.resolvedProviderId,
-        });
+        addSpanEvent("hebo.provider.resolved");
+        const genAiSignalLevel = config.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getEmbeddingsGeneralAttributes(ctx, genAiSignalLevel);
+        setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
         const embedOptions = convertToEmbedCallOptions(inputs);
         logger.trace({ requestId, options: embedOptions }, "[embeddings] AI SDK options");
         addSpanEvent("hebo.options.prepared");
+        setSpanAttributes(getEmbeddingsRequestAttributes(inputs, genAiSignalLevel));
         // Build middleware chain (model -> forward params -> provider).
         const embeddingModelWithMiddleware = wrapEmbeddingModel({
             model: embeddingModel,
@@ -82,12 +85,18 @@ export const embeddings = (config) => {
         });
         logger.trace({ requestId, result }, "[embeddings] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
+        // Transform result.
         ctx.result = toEmbeddings(result, ctx.modelId);
         addSpanEvent("hebo.result.transformed");
+        const genAiResponseAttrs = getEmbeddingsResponseAttributes(ctx.result, genAiSignalLevel);
+        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        setSpanAttributes(genAiResponseAttrs);
         if (hooks?.after) {
             ctx.result = (await hooks.after(ctx)) ?? ctx.result;
             addSpanEvent("hebo.hooks.after.completed");
         }
+        recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
         return ctx.result;
     };
     return { handler: winterCgHandler(handler, config) };

package/dist/endpoints/embeddings/otel.d.ts

@@ -0,0 +1,6 @@
+import type { Attributes } from "@opentelemetry/api";
+import type { Embeddings, EmbeddingsInputs } from "./schema";
+import { type GatewayContext, type TelemetrySignalLevel } from "../../types";
+export declare const getEmbeddingsGeneralAttributes: (ctx: GatewayContext, signalLevel?: TelemetrySignalLevel) => Attributes;
+export declare const getEmbeddingsRequestAttributes: (inputs: EmbeddingsInputs, signalLevel?: TelemetrySignalLevel) => Attributes;
+export declare const getEmbeddingsResponseAttributes: (embeddings: Embeddings, signalLevel?: TelemetrySignalLevel) => Attributes;

package/dist/endpoints/embeddings/otel.js

@@ -0,0 +1,35 @@
+import {} from "../../types";
+export const getEmbeddingsGeneralAttributes = (ctx, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const requestModel = typeof ctx.body?.model === "string" ? ctx.body.model : ctx.modelId;
+    return {
+        "gen_ai.operation.name": ctx.operation,
+        "gen_ai.request.model": requestModel,
+        "gen_ai.response.model": ctx.resolvedModelId,
+        "gen_ai.provider.name": ctx.resolvedProviderId,
+    };
+};
+export const getEmbeddingsRequestAttributes = (inputs, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const attrs = {};
+    if (signalLevel !== "required") {
+        Object.assign(attrs, {
+            "gen_ai.embeddings.dimension.count": inputs.dimensions,
+        });
+    }
+    return attrs;
+};
+export const getEmbeddingsResponseAttributes = (embeddings, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const attrs = {};
+    if (signalLevel !== "required") {
+        Object.assign(attrs, {
+            "gen_ai.usage.input_tokens": embeddings.usage?.prompt_tokens,
+            "gen_ai.usage.total_tokens": embeddings.usage?.total_tokens,
+        });
+    }
+    return attrs;
+};

package/dist/endpoints/models/handler.js

@@ -4,12 +4,11 @@ import { toModels, toModel } from "./converters";
 export const models = (config) => {
     // eslint-disable-next-line require-await
     const handler = async (ctx) => {
-        const request = ctx.request;
-        if (!request || request.method !== "GET") {
+        ctx.operation = "models";
+        if (!ctx.request || ctx.request.method !== "GET") {
             throw new GatewayError("Method Not Allowed", 405);
         }
-        ctx.operation = "models";
-        const rawId = request.url.split("/models/", 2)[1]?.split("?", 1)[0];
+        const rawId = ctx.request.url.split("/models/", 2)[1]?.split("?", 1)[0];
         if (!rawId) {
             return toModels(ctx.models);
         }

package/dist/errors/gateway.d.ts

@@ -1,5 +1,5 @@
 export declare class GatewayError extends Error {
     readonly status: number;
     readonly code: string;
-    constructor(error: string | Error, status: number, code?: string, cause?: unknown);
+    constructor(error: unknown, status: number, code?: string, cause?: unknown);
 }

package/dist/errors/gateway.js

@@ -3,11 +3,10 @@ export class GatewayError extends Error {
     status;
     code;
     constructor(error, status, code, cause) {
-        const msg = typeof error === "string" ? error : error.message;
-        super(msg);
+        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.cause);
     }
 }