@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/lifecycle.ts

@@ -1,135 +0,0 @@
-import type {
-  GatewayConfig,
-  GatewayContext,
-  OnRequestHookContext,
-  OnResponseHookContext,
-} from "./types";
-
-import { parseConfig } from "./config";
-import { GatewayError } from "./errors/gateway";
-import { toOpenAIErrorResponse } from "./errors/openai";
-import { logger } from "./logger";
-import { getBaggageAttributes } from "./telemetry/baggage";
-import { instrumentFetch } from "./telemetry/fetch";
-import { recordRequestDuration } from "./telemetry/gen-ai";
-import { getRequestAttributes, getResponseAttributes } from "./telemetry/http";
-import { recordV8jsMemory } from "./telemetry/memory";
-import { addSpanEvent, setSpanEventsEnabled, setSpanTracer, startSpan } from "./telemetry/span";
-import { wrapStream } from "./telemetry/stream";
-import { resolveOrCreateRequestId } from "./utils/request";
-import { prepareResponseInit, toResponse } from "./utils/response";
-
-export const winterCgHandler = (
-  run: (ctx: GatewayContext) => Promise<object | ReadableStream<object>>,
-  config: GatewayConfig,
-) => {
-  const parsedConfig = parseConfig(config);
-
-  if (parsedConfig.telemetry?.enabled) {
-    setSpanTracer(parsedConfig.telemetry?.tracer);
-    setSpanEventsEnabled(parsedConfig.telemetry?.signals?.hebo);
-    instrumentFetch(parsedConfig.telemetry?.signals?.hebo);
-  }
-
-  return async (request: Request, state?: Record<string, unknown>): Promise<Response> => {
-    const start = performance.now();
-    const ctx: GatewayContext = {
-      request,
-      state: state ?? {},
-      providers: parsedConfig.providers,
-      models: parsedConfig.models,
-      requestId: resolveOrCreateRequestId(request),
-    };
-
-    const span = startSpan(ctx.request.url);
-    span.setAttributes(getBaggageAttributes(ctx.request));
-    if (!span.isExisting) {
-      span.setAttributes(getRequestAttributes(ctx.request, parsedConfig.telemetry?.signals?.http));
-      span.setAttributes({ "http.request.id": ctx.requestId });
-    }
-
-    const finalize = (status: number, reason?: unknown) => {
-      if (ctx.operation) {
-        span.updateName(`${ctx.operation}${ctx.modelId ? ` ${ctx.modelId}` : ""}`);
-      }
-
-      if (!span.isExisting) {
-        // FUTURE add http.server.request.duration
-        span.setAttributes(
-          getResponseAttributes(ctx.response!, parsedConfig.telemetry?.signals?.http),
-        );
-      }
-
-      let realStatus = status;
-      if (ctx.request.signal.aborted) realStatus = 499;
-      else if (status === 200 && ctx.response?.status) realStatus = ctx.response.status;
-
-      if (realStatus !== 200) {
-        logger[realStatus >= 500 ? "error" : "warn"]({
-          requestId: ctx.requestId,
-          err: reason ?? ctx.request.signal.reason,
-        });
-
-        span.recordError(reason);
-      }
-      span.setAttributes({ "http.response.status_code_effective": realStatus });
-
-      if (ctx.operation === "chat" || ctx.operation === "embeddings") {
-        recordRequestDuration(
-          performance.now() - start,
-          realStatus,
-          ctx,
-          parsedConfig.telemetry?.signals?.gen_ai,
-        );
-      }
-
-      recordV8jsMemory(parsedConfig.telemetry?.signals?.hebo);
-
-      span.finish();
-    };
-
-    try {
-      if (parsedConfig.hooks?.onRequest) {
-        const onRequest = await parsedConfig.hooks.onRequest(ctx as OnRequestHookContext);
-        addSpanEvent("hebo.hooks.on_request.completed");
-
-        if (onRequest instanceof Response) {
-          ctx.response = onRequest;
-        }
-      }
-
-      if (!ctx.response) {
-        ctx.result = (await span.runWithContext(() => run(ctx))) as typeof ctx.result;
-
-        if (ctx.result instanceof ReadableStream) {
-          ctx.result = wrapStream(ctx.result, { onDone: finalize });
-        }
-
-        ctx.response = toResponse(ctx.result!, prepareResponseInit(ctx.requestId));
-      }
-
-      if (parsedConfig.hooks?.onResponse) {
-        const onResponse = await parsedConfig.hooks.onResponse(ctx as OnResponseHookContext);
-        addSpanEvent("hebo.hooks.on_response.completed");
-        if (onResponse) {
-          ctx.response = onResponse;
-        }
-      }
-
-      // FUTURE: this can leak if onResponse removed wrapper from response.body
-      if (!(ctx.result instanceof ReadableStream)) {
-        finalize(ctx.response.status);
-      }
-    } catch (error) {
-      ctx.response = toOpenAIErrorResponse(
-        ctx.request.signal.aborted
-          ? new GatewayError(error ?? ctx.request.signal.reason, 499)
-          : error,
-        prepareResponseInit(ctx.requestId),
-      );
-      finalize(ctx.response.status, error);
-    }
-
-    return ctx.response ?? new Response("Internal Server Error", { status: 500 });
-  };
-};

package/src/logger/default.ts

@@ -1,105 +0,0 @@
-import type { LogFn, LogLevel, Logger } from "./index";
-
-import { isProduction, isTest } from "../utils/env";
-
-const getDefaultLogLevel = (): LogLevel =>
-  isTest() ? "silent" : isProduction() ? "info" : "debug";
-
-const noop: LogFn = () => {};
-
-const LEVEL = {
-  trace: 5,
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40,
-  silent: 50,
-};
-const LEVELS = Object.keys(LEVEL) as (keyof typeof LEVEL)[];
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !(value instanceof Error);
-
-function serializeError(err: unknown, _seen?: WeakSet<object>): Record<string, unknown> {
-  if (!(err instanceof Error)) return { message: String(err) };
-
-  const seen = _seen ?? new WeakSet();
-  if (seen.has(err)) return { name: err.name, message: err.message, circular: true };
-  seen.add(err);
-
-  const out: Record<string, unknown> = {};
-
-  for (const k of Object.getOwnPropertyNames(err)) {
-    if (k.startsWith("_")) continue;
-
-    let val: unknown;
-    try {
-      val = (err as any)[k];
-    } catch {
-      val = "[Unreadable]";
-    }
-
-    if (typeof val === "bigint") val = `${val}n`;
-
-    // FUTURE: check for circular references within val
-    out[String(k)] = val instanceof Error ? serializeError(val, seen) : val;
-  }
-
-  return out;
-}
-
-const buildLogObject = (level: LogLevel, args: unknown[]): Record<string, unknown> => {
-  if (args.length === 0) return {};
-
-  const [first, second] = args;
-
-  let obj: Record<string, unknown> | undefined;
-  let err: Record<string, unknown> | undefined;
-  let msg: string | undefined;
-
-  if (first instanceof Error) {
-    err = serializeError(first);
-  } else if (isRecord(first)) {
-    if (first["err"] !== undefined) {
-      err = serializeError(first["err"]);
-      delete first["err"];
-    }
-    obj = first;
-  } else {
-    msg = String(first);
-  }
-
-  if (second !== undefined) {
-    msg = String(second);
-  }
-
-  if (err && msg === undefined) {
-    msg = err["message"] as string;
-  }
-
-  return {
-    level,
-    time: Date.now(),
-    ...(msg ? { msg } : {}),
-    ...(err ? { err } : {}),
-    ...obj,
-  };
-};
-
-const makeLogFn =
-  (level: LogLevel, write: (line: string) => void): LogFn =>
-  (...args: unknown[]) =>
-    write(JSON.stringify(buildLogObject(level, args)));
-
-export const createDefaultLogger = (config: { level?: LogLevel }): Logger => {
-  if (config.level === "silent" || getDefaultLogLevel() === "silent") {
-    return { trace: noop, debug: noop, info: noop, warn: noop, error: noop };
-  }
-
-  const threshold = LEVEL[config.level ?? getDefaultLogLevel()];
-  const enabled = (lvl: keyof typeof LEVEL) => LEVEL[lvl] >= threshold;
-
-  return Object.fromEntries(
-    LEVELS.map((lvl) => [lvl, enabled(lvl) ? makeLogFn(lvl, console.log) : noop]),
-  ) as Logger;
-};

package/src/logger/index.ts

@@ -1,42 +0,0 @@
-import { isTest } from "../utils/env";
-
-export type LogFn = {
-  (msg: string): void;
-  (obj: Record<string, unknown>, msg?: string): void;
-  (err: Error, msg?: string): void;
-};
-
-export type Logger = Record<"trace" | "debug" | "info" | "warn" | "error", LogFn>;
-export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "silent";
-export type LoggerConfig = { level?: LogLevel };
-
-const KEY = Symbol.for("@hebo/logger");
-type GlobalWithLogger = typeof globalThis & {
-  [KEY]?: Logger;
-};
-const g = globalThis as GlobalWithLogger;
-
-g[KEY] ??= {
-  trace: () => {},
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-};
-
-export let logger: Logger = g[KEY];
-
-export const isLogger = (input: Logger | LoggerConfig): input is Logger =>
-  typeof input === "object" && input !== null && "info" in input;
-
-export function isLoggerDisabled(input?: Logger | LoggerConfig | null): boolean {
-  if (isTest()) return true;
-  if (input === null) return true;
-  if (!input || typeof input !== "object" || "info" in input) return false;
-  return input.level === "silent";
-}
-
-export function setLoggerInstance(next: Logger) {
-  g[KEY] = next;
-  logger = g[KEY];
-}

package/src/middleware/common.test.ts

@@ -1,215 +0,0 @@
-import { MockLanguageModelV3 } from "ai/test";
-import { describe, expect, test } from "bun:test";
-
-import { extractProviderNamespace, forwardParamsMiddleware } from "./common";
-
-describe("extractProviderNamespace", () => {
-  test("should handle Google Vertex AI (google.vertex -> vertex)", () => {
-    expect(extractProviderNamespace("google.vertex.chat")).toBe("vertex");
-    expect(extractProviderNamespace("google.vertex.embedding")).toBe("vertex");
-    expect(extractProviderNamespace("google.vertex.image")).toBe("vertex");
-    expect(extractProviderNamespace("google.vertex.video")).toBe("vertex");
-  });
-
-  test("should handle Google Generative AI (google.others -> google)", () => {
-    expect(extractProviderNamespace("google.generative-ai.chat")).toBe("google");
-    expect(extractProviderNamespace("google.generative-ai.embedding")).toBe("google");
-    expect(extractProviderNamespace("google.generative-ai.image")).toBe("google");
-    expect(extractProviderNamespace("google.generative-ai.video")).toBe("google");
-  });
-
-  test("should handle Amazon Bedrock special case", () => {
-    expect(extractProviderNamespace("amazon-bedrock")).toBe("bedrock");
-  });
-
-  test("should handle OpenAI (default to first component)", () => {
-    expect(extractProviderNamespace("openai.chat")).toBe("openai");
-    expect(extractProviderNamespace("openai.embedding")).toBe("openai");
-  });
-
-  test("should handle Anthropic and its infrastructure variants", () => {
-    expect(extractProviderNamespace("anthropic.messages")).toBe("anthropic");
-    expect(extractProviderNamespace("vertex.anthropic.messages")).toBe("vertex");
-    expect(extractProviderNamespace("bedrock.anthropic.messages")).toBe("bedrock");
-  });
-
-  test("should handle Azure (default to first component)", () => {
-    expect(extractProviderNamespace("azure.chat")).toBe("azure");
-    expect(extractProviderNamespace("azure.embedding")).toBe("azure");
-  });
-});
-
-describe("forwardParamsMiddleware", () => {
-  test("should snakize providerMetadata in generate output", async () => {
-    const middleware = forwardParamsMiddleware("google.vertex.chat");
-    const model = new MockLanguageModelV3({
-      modelId: "google/gemini-2.5-flash",
-      // oxlint-disable-next-line require-await
-      doGenerate: async () => ({
-        content: [{ type: "text", text: "hi" }],
-        finishReason: "stop",
-        usage: { promptTokens: 1, completionTokens: 1 },
-        providerMetadata: {
-          vertex: {
-            thoughtSignature: "encrypted-signature",
-          },
-        },
-        warnings: [],
-      }),
-    });
-
-    const result = await middleware.wrapGenerate!({
-      model,
-      params: { prompt: [] },
-      doGenerate: () => model.doGenerate({ prompt: [] }),
-      doStream: () => model.doStream({ prompt: [] }),
-    });
-
-    expect(result.providerMetadata).toEqual({
-      vertex: {
-        thought_signature: "encrypted-signature",
-      },
-    });
-  });
-
-  test("should snakize providerMetadata in generate output content parts", async () => {
-    const middleware = forwardParamsMiddleware("google.vertex.chat");
-    const model = new MockLanguageModelV3({
-      modelId: "google/gemini-2.5-flash",
-      // oxlint-disable-next-line require-await
-      doGenerate: async () => ({
-        content: [
-          {
-            type: "text",
-            text: "hi",
-            providerMetadata: { vertex: { thoughtSignature: "part-sig" } },
-          },
-        ],
-        finishReason: "stop",
-        usage: { promptTokens: 1, completionTokens: 1 },
-        warnings: [],
-      }),
-    });
-
-    const result = await middleware.wrapGenerate!({
-      model,
-      params: { prompt: [] },
-      doGenerate: () => model.doGenerate({ prompt: [] }),
-      doStream: () => model.doStream({ prompt: [] }),
-    });
-
-    expect(result.content[0].providerMetadata).toEqual({
-      vertex: {
-        thought_signature: "part-sig",
-      },
-    });
-  });
-
-  test("should snakize providerMetadata in stream parts", async () => {
-    const middleware = forwardParamsMiddleware("google.vertex.chat");
-    const model = new MockLanguageModelV3({
-      modelId: "google/gemini-2.5-flash",
-      // oxlint-disable-next-line require-await
-      doStream: async () => ({
-        stream: new ReadableStream({
-          start(controller) {
-            controller.enqueue({
-              type: "text-delta",
-              id: "1",
-              delta: "hi",
-              providerMetadata: { vertex: { thoughtSignature: "part-signature" } },
-            });
-            controller.enqueue({
-              type: "finish",
-              finishReason: "stop",
-              usage: { promptTokens: 1, completionTokens: 1 },
-            });
-            controller.close();
-          },
-        }),
-      }),
-    });
-
-    const result = await middleware.wrapStream!({
-      model,
-      params: { prompt: [] },
-      doGenerate: () => model.doGenerate({ prompt: [] }),
-      doStream: () => model.doStream({ prompt: [] }),
-    });
-
-    const reader = result.stream.getReader();
-    const part = await reader.read();
-    expect(part.value.providerMetadata).toEqual({
-      vertex: { thought_signature: "part-signature" },
-    });
-  });
-
-  test("should camelize providerOptions on the way in", async () => {
-    const middleware = forwardParamsMiddleware("google.vertex.chat");
-    const params = {
-      prompt: [],
-      providerOptions: {
-        vertex: { thought_signature: "in-signature" },
-      },
-    };
-
-    const result = await middleware.transformParams!({
-      type: "generate",
-      params,
-      model: new MockLanguageModelV3({ modelId: "google/gemini-2.5-flash" }),
-    });
-
-    expect(result.providerOptions).toEqual({
-      vertex: { thoughtSignature: "in-signature" },
-    });
-  });
-
-  test("should merge unknown.reasoning_effort into openai.reasoningEffort for gpt-5", async () => {
-    const middleware = forwardParamsMiddleware("openai.chat");
-    const params = {
-      prompt: [],
-      providerOptions: {
-        unknown: { reasoning_effort: "low" },
-      },
-    };
-
-    const result = await middleware.transformParams!({
-      type: "generate",
-      params,
-      model: new MockLanguageModelV3({ modelId: "openai/gpt-5" }),
-    });
-
-    expect(result.providerOptions).toEqual({
-      openai: { reasoningEffort: "low" },
-    });
-    expect(result.providerOptions!.unknown).toBeUndefined();
-  });
-
-  test("should merge all providerOptions into target providerName and reserve others", async () => {
-    const middleware = forwardParamsMiddleware("anthropic.messages");
-    const params = {
-      prompt: [],
-      providerOptions: {
-        unknown: { some_option: "value1" },
-        openai: { other_option: "value2" },
-        anthropic: { existing_option: "value3" },
-      },
-    };
-
-    const result = await middleware.transformParams!({
-      type: "generate",
-      params,
-      model: new MockLanguageModelV3({ modelId: "anthropic/claude-3-5-sonnet" }),
-    });
-
-    expect(result.providerOptions).toEqual({
-      anthropic: {
-        someOption: "value1",
-        otherOption: "value2",
-        existingOption: "value3",
-      },
-      openai: { other_option: "value2" },
-    });
-    expect(result.providerOptions!.unknown).toBeUndefined();
-  });
-});

package/src/middleware/common.ts

@@ -1,163 +0,0 @@
-import type { JSONObject } from "@ai-sdk/provider";
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-
-import type { ProviderId } from "../providers/types";
-
-function snakeToCamel(key: string): string {
-  if (key.indexOf("_") === -1) return key;
-
-  let out = "";
-  for (let i = 0; i < key.length; i++) {
-    const c = key[i]!;
-    if (c === "_" && i + 1 < key.length) {
-      const next = key[i + 1]!;
-      if (next >= "a" && next <= "z") {
-        out += next.toUpperCase();
-        i++;
-        continue;
-      }
-    }
-    out += c;
-  }
-
-  return out;
-}
-
-function hasUppercase(s: string): boolean {
-  for (let i = 0; i < s.length; i++) {
-    const c = s[i]!;
-    if (c >= "A" && c <= "Z") return true;
-  }
-  return false;
-}
-
-function camelToSnake(key: string): string {
-  if (!hasUppercase(key)) return key;
-
-  let out = "";
-  for (let i = 0; i < key.length; i++) {
-    const c = key[i]!;
-    out += c >= "A" && c <= "Z" ? "_" + c.toLowerCase() : c;
-  }
-  return out;
-}
-
-function remapDeep(value: unknown, mapKey: (k: string) => string): unknown {
-  if (value === null || typeof value !== "object") return value;
-
-  if (Array.isArray(value)) {
-    return value.map((v) => remapDeep(v, mapKey));
-  }
-
-  const out: Record<string, unknown> = {};
-  for (const key of Object.keys(value)) {
-    out[mapKey(key)] = remapDeep((value as Record<string, unknown>)[key], mapKey);
-  }
-  return out;
-}
-
-function processOptions(options: Record<string, JSONObject>, providerName: ProviderId) {
-  const target = (options[providerName] = remapDeep(
-    options[providerName] ?? {},
-    snakeToCamel,
-  ) as JSONObject) as Record<string, JSONObject>;
-
-  for (const namespace in options) {
-    if (namespace === providerName) continue;
-    Object.assign(
-      target,
-      remapDeep(options[namespace], snakeToCamel) as Record<string, JSONObject>,
-    );
-    if (namespace === "unknown") delete options[namespace];
-  }
-}
-
-function processMetadata(metadata: Record<string, JSONObject>) {
-  for (const namespace in metadata) {
-    metadata[namespace] = remapDeep(metadata[namespace], camelToSnake) as JSONObject;
-  }
-}
-
-/**
- * Converts snake_case params in providerOptions to camelCase
- * and moves all of them into providerOptions[providerName].
- * Also snakizes values in providerMetadata for OpenAI compatibility.
- */
-export function forwardLanguageParams(providerName: ProviderId): LanguageModelMiddleware {
-  return {
-    specificationVersion: "v3",
-    // oxlint-disable-next-line require-await
-    transformParams: async ({ params }) => {
-      if (params.providerOptions) processOptions(params.providerOptions, providerName);
-
-      for (const message of params.prompt) {
-        if (message.providerOptions) {
-          processOptions(message.providerOptions, providerName);
-        }
-        if (message.content && Array.isArray(message.content)) {
-          for (const part of message.content) {
-            if ("providerOptions" in part && part.providerOptions) {
-              processOptions(part.providerOptions as Record<string, JSONObject>, providerName);
-            }
-          }
-        }
-      }
-
-      return params;
-    },
-    wrapGenerate: async ({ doGenerate }) => {
-      const result = await doGenerate();
-      if (result.providerMetadata) processMetadata(result.providerMetadata);
-      result.content?.forEach((part) => {
-        if (part.providerMetadata) processMetadata(part.providerMetadata);
-      });
-      return result;
-    },
-    wrapStream: async ({ doStream }) => {
-      const result = await doStream();
-      result.stream = result.stream.pipeThrough(
-        new TransformStream({
-          transform(part, controller) {
-            if ("providerMetadata" in part && part.providerMetadata) {
-              processMetadata(part.providerMetadata);
-            }
-            controller.enqueue(part);
-          },
-        }),
-      );
-      return result;
-    },
-  };
-}
-
-export function forwardEmbeddingParams(providerName: ProviderId): EmbeddingModelMiddleware {
-  return {
-    specificationVersion: "v3",
-    // oxlint-disable-next-line require-await
-    transformParams: async ({ params }) => {
-      if (params.providerOptions) processOptions(params.providerOptions, providerName);
-      return params;
-    },
-    wrapEmbed: async ({ doEmbed }) => {
-      const result = await doEmbed();
-      if (result.providerMetadata) processMetadata(result.providerMetadata);
-      return result;
-    },
-  };
-}
-
-export function extractProviderNamespace(id: string): string {
-  if (id === "amazon-bedrock") return "bedrock";
-  const [first, second] = id.split(".");
-  // FUTURE: map vertex to google once AI SDK support per-message level provider options
-  if (first === "vertex" || second === "vertex") return "vertex";
-  return first!;
-}
-
-export function forwardParamsMiddleware(provider: string): LanguageModelMiddleware {
-  return forwardLanguageParams(extractProviderNamespace(provider));
-}
-
-export function forwardParamsEmbeddingMiddleware(provider: string): EmbeddingModelMiddleware {
-  return forwardEmbeddingParams(extractProviderNamespace(provider));
-}

package/src/middleware/debug.ts

@@ -1,37 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-
-import { logger } from "../logger";
-
-export const debugFinalParamsMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    logger.trace(
-      {
-        kind: "text",
-        modelId: model.modelId,
-        providerId: model.provider,
-        params,
-      },
-      "[middleware] final params",
-    );
-    return params;
-  },
-};
-
-export const debugEmbeddingFinalParamsMiddleware: EmbeddingModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    logger.trace(
-      {
-        kind: "embedding",
-        modelId: model.modelId,
-        providerId: model.provider,
-        params,
-      },
-      "[middleware] final params",
-    );
-    return params;
-  },
-};