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

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

@@ -23,16 +23,24 @@ 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: 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.
@@ -43,22 +51,21 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
     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 as BeforeHookContext)) ?? ctx.body;
       addSpanEvent("hebo.hooks.before.completed");
@@ -71,10 +78,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 =
@@ -89,7 +93,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);
@@ -101,6 +109,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({
@@ -116,25 +125,25 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
         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 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);
+          recordRequestDuration(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
         },
         experimental_include: {
           requestBody: false,
@@ -142,10 +151,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;
@@ -161,24 +168,30 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
       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");
     }
 
+    recordRequestDuration(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
     return ctx.result;
   };
 

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

@@ -0,0 +1,154 @@
+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;
+  }
+
+  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, {
+      "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: 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,24 @@ 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: 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.
@@ -36,22 +44,21 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
     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 as BeforeHookContext)) ?? ctx.body;
       addSpanEvent("hebo.hooks.before.completed");
@@ -64,10 +71,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 =
@@ -82,14 +86,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({
@@ -108,14 +115,19 @@ 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");
     }
 
+    recordRequestDuration(performance.now() - 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

@@ -9,7 +9,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 as { cause?: unknown }).cause);
+    this.cause = cause ?? (typeof error === "string" ? undefined : error);
   }
 }

package/src/errors/openai.ts

@@ -22,28 +22,35 @@ 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")))) {
+    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: unknown): OpenAIError {
   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: unknown, responseInit?: 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), {
-    ...responseInit,
-    status: meta.status,
-    statusText: meta.code,
-  });
+  return toResponse(
+    new OpenAIError(
+      maybeMaskMessage(meta, resolveRequestId(responseInit)),
+      mapType(meta.status),
+      meta.code,
+    ),
+    {
+      ...responseInit,
+      status: meta.status,
+      statusText: meta.code,
+    },
+  );
 }

package/src/errors/utils.ts

@@ -23,26 +23,24 @@ export const STATUS_CODE = (status: number) => {
   return status >= 400 && status < 500 ? STATUS_CODES[400] : STATUS_CODES[500];
 };
 
+// FUTURE: always return a wrapped GatewayError?
 export function getErrorMeta(error: unknown) {
   const message = error instanceof Error ? error.message : String(error);
 
-  let code: string;
   let status: number;
-  let param = "";
+  let code: string;
 
   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/src/gateway.ts

@@ -30,7 +30,7 @@ export function gateway(config: GatewayConfig) {
       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);