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

package/README.md

@@ -615,12 +615,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",
+    },
   },
 });
 ```

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.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",
@@ -348,9 +349,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();
                     }
                 }
             },

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, 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") {
@@ -20,21 +24,20 @@ export const chatCompletions = (config) => {
         }
         const requestId = resolveRequestId(ctx.request);
         // Parse + validate input.
-        let body;
         try {
-            body = await ctx.request.json();
+            ctx.body = await ctx.request.json();
         }
         catch {
             throw new GatewayError("Invalid JSON", 400);
         }
         addSpanEvent("hebo.request.deserialized");
-        const parsed = ChatCompletionsBodySchema.safeParse(body);
+        const parsed = ChatCompletionsBodySchema.safeParse(ctx.body);
         if (!parsed.success) {
+            // FUTURE: add body shape to error message
             throw new GatewayError(z.prettifyError(parsed.error), 400);
         }
         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");
@@ -45,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 ??
@@ -61,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({
@@ -69,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,
@@ -82,22 +86,21 @@ export const chatCompletions = (config) => {
                 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;
+                timeout: {
+                    totalMs: 5 * 60 * 1000,
                 },
                 onAbort: () => {
                     throw new DOMException("Upstream failed", "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);
+                    recordRequestDuration(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
                 },
                 experimental_include: {
                     requestBody: false,
@@ -105,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");
@@ -120,21 +121,26 @@ export const chatCompletions = (config) => {
             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");
         }
+        recordRequestDuration(performance.now() - 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,121 @@
+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;
+    }
+    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, {
+            "gen_ai.system_instructions": inputs.messages
+                .filter((m) => m.role === "system")
+                .map((m) => JSON.stringify({ parts: [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, 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") {
@@ -20,21 +24,20 @@ export const embeddings = (config) => {
         }
         const requestId = resolveRequestId(ctx.request);
         // Parse + validate input.
-        let body;
         try {
-            body = await ctx.request.json();
+            ctx.body = await ctx.request.json();
         }
         catch {
             throw new GatewayError("Invalid JSON", 400);
         }
         addSpanEvent("hebo.request.deserialized");
-        const parsed = EmbeddingsBodySchema.safeParse(body);
+        const parsed = EmbeddingsBodySchema.safeParse(ctx.body);
         if (!parsed.success) {
+            // FUTURE: add body shape to error message
             throw new GatewayError(z.prettifyError(parsed.error), 400);
         }
         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");
@@ -45,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 ??
@@ -61,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,
@@ -83,12 +85,17 @@ 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");
         }
+        recordRequestDuration(performance.now() - 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.js

@@ -7,7 +7,6 @@ export class GatewayError extends Error {
         super(msg);
         this.status = status;
         this.code = code ?? STATUS_CODE(status);
-        this.cause =
-            cause ?? (typeof error === "string" ? undefined : error.cause);
+        this.cause = cause ?? (typeof error === "string" ? undefined : error);
     }
 }

package/dist/errors/openai.js

@@ -17,23 +17,21 @@ export class OpenAIError {
         this.error = { message, type, code: code?.toLowerCase(), param };
     }
 }
+const mapType = (status) => (status < 500 ? "invalid_request_error" : "server_error");
+const maybeMaskMessage = (meta, requestId) => {
+    if (!(isProduction() && (meta.status >= 500 || meta.code.includes("UPSTREAM")))) {
+        return meta.message;
+    }
+    // FUTURE: always attach requestId to errors (masked and unmasked)
+    return `${STATUS_CODE(meta.status)} (${requestId ?? "see requestId in response headers"})`;
+};
 export function toOpenAIError(error) {
     const meta = getErrorMeta(error);
-    return new OpenAIError(meta.message, meta.type, meta.code);
+    return new OpenAIError(maybeMaskMessage(meta), mapType(meta.status), meta.code);
 }
 export function toOpenAIErrorResponse(error, responseInit) {
     const meta = getErrorMeta(error);
-    const shouldMask = isProduction() && (meta.status >= 500 || meta.code.includes("UPSTREAM"));
-    let message;
-    if (shouldMask) {
-        const requestId = resolveRequestId(responseInit);
-        // FUTURE: always attach requestId to errors (masked and unmasked)
-        message = `${STATUS_CODE(meta.status)} (${requestId})`;
-    }
-    else {
-        message = meta.message;
-    }
-    return toResponse(new OpenAIError(message, meta.type, meta.code), {
+    return toResponse(new OpenAIError(maybeMaskMessage(meta, resolveRequestId(responseInit)), mapType(meta.status), meta.code), {
         ...responseInit,
         status: meta.status,
         statusText: meta.code,

package/dist/errors/utils.d.ts

@@ -15,9 +15,7 @@ export declare const STATUS_CODES: {
 };
 export declare const STATUS_CODE: (status: number) => "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "CONFLICT" | "UNPROCESSABLE_ENTITY" | "TOO_MANY_REQUESTS" | "INTERNAL_SERVER_ERROR" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT";
 export declare function getErrorMeta(error: unknown): {
-    code: string;
     status: number;
-    param: string;
-    type: string;
+    code: string;
     message: string;
 };

package/dist/errors/utils.js

@@ -21,24 +21,23 @@ export const STATUS_CODE = (status) => {
         return label;
     return status >= 400 && status < 500 ? STATUS_CODES[400] : STATUS_CODES[500];
 };
+// FUTURE: always return a wrapped GatewayError?
 export function getErrorMeta(error) {
     const message = error instanceof Error ? error.message : String(error);
-    let code;
     let status;
-    let param = "";
+    let code;
     if (error instanceof GatewayError) {
-        ({ code, status } = error);
+        ({ status, code } = error);
     }
     else {
         const normalized = normalizeAiSdkError(error);
         if (normalized) {
-            ({ code, status } = normalized);
+            ({ status, code } = normalized);
         }
         else {
             status = 500;
             code = STATUS_CODE(status);
         }
     }
-    const type = status < 500 ? "invalid_request_error" : "server_error";
-    return { code, status, param, type, message };
+    return { status, code, message };
 }

package/dist/gateway.js

@@ -22,7 +22,7 @@ export function gateway(config) {
         if (basePath && pathname.startsWith(basePath)) {
             pathname = pathname.slice(basePath.length);
         }
-        logger.debug(`[gateway] ${req.method} ${pathname}`);
+        logger.info(`[gateway] ${req.method} ${pathname}`);
         for (const [route, endpoint] of routeEntries) {
             if (pathname === route || pathname.startsWith(route + "/")) {
                 return endpoint.handler(req, state);