@hebo-ai/gateway 0.4.0-beta.3 → 0.4.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",
@@ -404,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(
@@ -416,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;
@@ -534,10 +536,15 @@ export class ChatCompletionsStream extends TransformStream<
           }
 
           case "error": {
-            const error = part.error;
-            // FUTURE mask in production mode and return responseID
-            controller.enqueue(toOpenAIError(error));
-            break;
+            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,16 +23,28 @@ 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: GatewayConfig): Endpoint => {
   const hooks = config.hooks;
 
   const handler = async (ctx: GatewayContext) => {
+    const start = performance.now();
+    ctx.operation = "chat";
     addSpanEvent("hebo.handler.started");
 
     // Guard: enforce HTTP method early.
@@ -52,12 +64,12 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
 
     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 as BeforeHookContext)) ?? ctx.body;
       addSpanEvent("hebo.hooks.before.completed");
@@ -70,10 +82,7 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
     ctx.resolvedModelId =
       (await hooks?.resolveModelId?.(ctx as ResolveModelHookContext)) ?? 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 as ResolveProviderHookContext);
     ctx.provider =
@@ -88,7 +97,11 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
     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);
@@ -100,6 +113,7 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
       "[chat] AI SDK options",
     );
     addSpanEvent("hebo.options.prepared");
+    setSpanAttributes(getChatRequestAttributes(inputs, genAiSignalLevel));
 
     // Build middleware chain (model -> forward params -> provider).
     const languageModelWithMiddleware = wrapLanguageModel({
@@ -113,27 +127,27 @@ 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,
-        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 as unknown as GenerateTextResult<ToolSet, Output.Output>,
+        onError: () => {},
+        onFinish: (res) => {
+          addSpanEvent("hebo.ai-sdk.completed");
+          const streamResult = toChatCompletions(
+            res as unknown as GenerateTextResult<ToolSet, Output.Output>,
             ctx.resolvedModelId!,
           );
-        },
-        timeout: {
-          totalMs: 5 * 60 * 1000,
+          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,
@@ -141,10 +155,8 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
         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 as AfterHookContext)) ?? ctx.result;
@@ -158,26 +170,32 @@ 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: {
         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 as AfterHookContext)) ?? ctx.result;
       addSpanEvent("hebo.hooks.after.completed");
     }
 
+    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+    recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
     return ctx.result;
   };
 

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

@@ -0,0 +1,161 @@
+import type { Attributes } from "@opentelemetry/api";
+
+import type {
+  ChatCompletions,
+  ChatCompletionsBody,
+  ChatCompletionsContentPart,
+  ChatCompletionsMessage,
+} from "./schema";
+
+import { type GatewayContext, type TelemetrySignalLevel } from "../../types";
+
+const toTextPart = (content: string): Record<string, unknown> => ({ type: "text", content });
+
+const toMessageParts = (message: ChatCompletionsMessage): Record<string, unknown>[] => {
+  if (message.role === "assistant") {
+    const parts: Record<string, unknown>[] = [];
+    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: Record<string, unknown>[] = [];
+    if (typeof message.content === "string") parts.push(toTextPart(message.content));
+    if (Array.isArray(message.content)) {
+      for (const part of message.content as ChatCompletionsContentPart[]) {
+        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: GatewayContext,
+  signalLevel?: TelemetrySignalLevel,
+): Attributes => {
+  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: ChatCompletionsBody,
+  signalLevel?: TelemetrySignalLevel,
+): Attributes => {
+  if (!signalLevel || signalLevel === "off") return {};
+
+  const attrs: Attributes = {};
+
+  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: ChatCompletions,
+  signalLevel?: TelemetrySignalLevel,
+): Attributes => {
+  if (!signalLevel || signalLevel === "off") return {};
+
+  const attrs: Attributes = {
+    "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/src/endpoints/embeddings/handler.test.ts

@@ -45,7 +45,7 @@ describe("Embeddings Handler", () => {
     models: {
       "text-embedding-3-small": {
         name: "OpenAI Embedding Model",
-        modalities: { input: ["text"], output: ["embeddings"] },
+        modalities: { input: ["text"], output: ["embedding"] },
         providers: ["openai"],
       },
       "gpt-oss-20b": {
@@ -68,7 +68,7 @@ describe("Embeddings Handler", () => {
     expect(data).toMatchObject({
       error: {
         code: "model_unsupported_operation",
-        message: "Model 'gpt-oss-20b' does not support 'embeddings' output",
+        message: "Model 'gpt-oss-20b' does not support 'embedding' output",
         type: "invalid_request_error",
       },
     });

package/src/endpoints/embeddings/handler.ts

@@ -16,16 +16,28 @@ 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: GatewayConfig): Endpoint => {
   const hooks = config.hooks;
 
   const handler = async (ctx: GatewayContext) => {
+    const start = performance.now();
+    ctx.operation = "embeddings";
     addSpanEvent("hebo.handler.started");
 
     // Guard: enforce HTTP method early.
@@ -45,12 +57,12 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
 
     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 as BeforeHookContext)) ?? ctx.body;
       addSpanEvent("hebo.hooks.before.completed");
@@ -63,10 +75,7 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
     ctx.resolvedModelId =
       (await hooks?.resolveModelId?.(ctx as ResolveModelHookContext)) ?? 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 as ResolveProviderHookContext);
     ctx.provider =
@@ -81,14 +90,17 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
     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({
@@ -107,14 +119,20 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
     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 as AfterHookContext)) ?? ctx.result;
       addSpanEvent("hebo.hooks.after.completed");
     }
 
+    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+    recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
     return ctx.result;
   };
 

package/src/endpoints/embeddings/otel.ts

@@ -0,0 +1,56 @@
+import type { Attributes } from "@opentelemetry/api";
+
+import type { Embeddings, EmbeddingsInputs } from "./schema";
+
+import { type GatewayContext, type TelemetrySignalLevel } from "../../types";
+
+export const getEmbeddingsGeneralAttributes = (
+  ctx: GatewayContext,
+  signalLevel?: TelemetrySignalLevel,
+): Attributes => {
+  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: EmbeddingsInputs,
+  signalLevel?: TelemetrySignalLevel,
+): Attributes => {
+  if (!signalLevel || signalLevel === "off") return {};
+
+  const attrs: Attributes = {};
+
+  if (signalLevel !== "required") {
+    Object.assign(attrs, {
+      "gen_ai.embeddings.dimension.count": inputs.dimensions,
+    });
+  }
+
+  return attrs;
+};
+
+export const getEmbeddingsResponseAttributes = (
+  embeddings: Embeddings,
+  signalLevel?: TelemetrySignalLevel,
+): Attributes => {
+  if (!signalLevel || signalLevel === "off") return {};
+
+  const attrs: Attributes = {};
+
+  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/src/endpoints/models/handler.ts

@@ -7,15 +7,13 @@ import { toModels, toModel } from "./converters";
 export const models = (config: GatewayConfig): Endpoint => {
   // eslint-disable-next-line require-await
   const handler = async (ctx: GatewayContext) => {
-    const request = ctx.request;
+    ctx.operation = "models";
 
-    if (!request || request.method !== "GET") {
+    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/src/errors/gateway.ts

@@ -4,12 +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 as { cause?: unknown }).cause);
   }
 }