@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/endpoints/embeddings/otel.ts

@@ -1,40 +0,0 @@
-import type { Attributes } from "@opentelemetry/api";
-
-import type { Embeddings, EmbeddingsInputs } from "./schema";
-
-import { type TelemetrySignalLevel } from "../../types";
-
-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/embeddings/schema.ts

@@ -1,36 +0,0 @@
-import * as z from "zod";
-
-export const EmbeddingsInputsSchema = z.object({
-  input: z.union([z.string(), z.array(z.string())]),
-  dimensions: z.int().nonnegative().max(65536).optional(),
-});
-export type EmbeddingsInputs = z.infer<typeof EmbeddingsInputsSchema>;
-
-export const EmbeddingsBodySchema = z.looseObject({
-  model: z.string(),
-  ...EmbeddingsInputsSchema.shape,
-});
-export type EmbeddingsBody = z.infer<typeof EmbeddingsBodySchema>;
-
-export const EmbeddingsDataSchema = z.object({
-  object: z.literal("embedding"),
-  embedding: z.array(z.number()),
-  index: z.int().nonnegative(),
-});
-export type EmbeddingsData = z.infer<typeof EmbeddingsDataSchema>;
-
-export const EmbeddingsUsageSchema = z.object({
-  prompt_tokens: z.int().nonnegative().optional(),
-  total_tokens: z.int().nonnegative().optional(),
-});
-export type EmbeddingsUsage = z.infer<typeof EmbeddingsUsageSchema>;
-
-export const EmbeddingsSchema = z.object({
-  object: z.literal("list"),
-  data: z.array(EmbeddingsDataSchema),
-  model: z.string(),
-  usage: EmbeddingsUsageSchema.nullable(),
-  // Extensions
-  provider_metadata: z.unknown().optional().meta({ extension: true }),
-});
-export type Embeddings = z.infer<typeof EmbeddingsSchema>;

package/src/endpoints/models/converters.ts

@@ -1,56 +0,0 @@
-import type { ModelCatalog, CatalogModel } from "../../models/types";
-import type { ModelList, Model } from "./schema";
-
-import { toResponse } from "../../utils/response";
-
-export function toModel(id: string, catalogModel: CatalogModel): Model {
-  const { created, providers, modalities, additionalProperties, ...rest } = catalogModel;
-  let createdTimestamp = Math.floor(Date.now() / 1000);
-  if (created) {
-    const parsed = Date.parse(created);
-    if (!isNaN(parsed)) {
-      createdTimestamp = Math.floor(parsed / 1000);
-    }
-  }
-
-  const model = {
-    id,
-    object: "model" as const,
-    created: createdTimestamp,
-    owned_by: id.split("/")[0] || "system",
-    architecture: {
-      input_modalities: modalities?.input || [],
-      modality:
-        modalities?.input &&
-        modalities?.output &&
-        `${modalities.input?.[0]}->${modalities.output?.[0]}`,
-      output_modalities: modalities?.output || [],
-    },
-    endpoints:
-      providers?.map((provider) => ({
-        tag: provider,
-      })) || [],
-    ...rest,
-    ...additionalProperties,
-  };
-
-  return model;
-}
-
-export function toModels(models: ModelCatalog): ModelList {
-  return {
-    object: "list",
-    data: Object.entries(models).map(([id, catalogModel]) => toModel(id, catalogModel!)),
-  };
-}
-export function createModelsResponse(models: ModelCatalog, responseInit?: ResponseInit): Response {
-  return toResponse(toModels(models), responseInit);
-}
-
-export function createModelResponse(
-  id: string,
-  catalogModel: CatalogModel,
-  responseInit?: ResponseInit,
-): Response {
-  return toResponse(toModel(id, catalogModel), responseInit);
-}

package/src/endpoints/models/handler.test.ts

@@ -1,122 +0,0 @@
-import { MockProviderV3 } from "ai/test";
-import { describe, expect, test } from "bun:test";
-
-import { parseResponse } from "../../../test/helpers/http";
-import { models } from "./handler";
-
-const baseUrl = "http://localhost/models";
-
-describe("Models Handler", () => {
-  const endpoint = models({
-    providers: {
-      anthropic: new MockProviderV3(),
-      google: new MockProviderV3(),
-    },
-    models: {
-      "anthropic/claude-opus-4.5": {
-        name: "Claude Opus 4.5",
-        created: "2025-09-29T10:00:00.000Z",
-        knowledge: "2025-07",
-        modalities: {
-          input: ["text", "image"],
-          output: ["text"],
-        },
-        context: 200000,
-        capabilities: ["reasoning", "tool_call"],
-        providers: ["anthropic"],
-      },
-      "google/gemini-3-flash": {
-        name: "Gemini 3 Flash",
-        created: "2025-10-01T08:30:00.000Z",
-        modalities: {
-          input: ["text", "video"],
-          output: ["text"],
-        },
-        context: 128000,
-        providers: ["google"],
-      },
-    },
-  });
-
-  test("should list models via GET request with realistic data (exact match)", async () => {
-    const request = new Request(baseUrl, { method: "GET" });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toEqual({
-      object: "list",
-      data: [
-        {
-          id: "anthropic/claude-opus-4.5",
-          object: "model",
-          created: Math.floor(Date.parse("2025-09-29T10:00:00.000Z") / 1000),
-          owned_by: "anthropic",
-          name: "Claude Opus 4.5",
-          knowledge: "2025-07",
-          context: 200000,
-          capabilities: ["reasoning", "tool_call"],
-          architecture: {
-            modality: "text->text",
-            input_modalities: ["text", "image"],
-            output_modalities: ["text"],
-          },
-          endpoints: [{ tag: "anthropic" }],
-        },
-        {
-          id: "google/gemini-3-flash",
-          object: "model",
-          created: Math.floor(Date.parse("2025-10-01T08:30:00.000Z") / 1000),
-          owned_by: "google",
-          name: "Gemini 3 Flash",
-          context: 128000,
-          architecture: {
-            modality: "text->text",
-            input_modalities: ["text", "video"],
-            output_modalities: ["text"],
-          },
-          endpoints: [{ tag: "google" }],
-        },
-      ],
-    });
-  });
-
-  test("should return a single model by ID", async () => {
-    const request = new Request(`${baseUrl}/anthropic/claude-opus-4.5`, { method: "GET" });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toEqual({
-      id: "anthropic/claude-opus-4.5",
-      object: "model",
-      created: Math.floor(Date.parse("2025-09-29T10:00:00.000Z") / 1000),
-      owned_by: "anthropic",
-      name: "Claude Opus 4.5",
-      knowledge: "2025-07",
-      context: 200000,
-      capabilities: ["reasoning", "tool_call"],
-      architecture: {
-        modality: "text->text",
-        input_modalities: ["text", "image"],
-        output_modalities: ["text"],
-      },
-      endpoints: [{ tag: "anthropic" }],
-    });
-  });
-
-  test("should return 'Method Not Allowed' for POST request", async () => {
-    const request = new Request(baseUrl, { method: "POST" });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toMatchObject({
-      error: {
-        code: "method_not_allowed",
-        message: "Method Not Allowed",
-        type: "invalid_request_error",
-      },
-    });
-  });
-});

package/src/endpoints/models/handler.ts

@@ -1,37 +0,0 @@
-import type { GatewayConfig, Endpoint, GatewayContext } from "../../types";
-
-import { GatewayError } from "../../errors/gateway";
-import { winterCgHandler } from "../../lifecycle";
-import { toModels, toModel } from "./converters";
-
-export const models = (config: GatewayConfig): Endpoint => {
-  // oxlint-disable-next-line require-await
-  const handler = async (ctx: GatewayContext) => {
-    ctx.operation = "models";
-
-    if (!ctx.request || ctx.request.method !== "GET") {
-      throw new GatewayError("Method Not Allowed", 405);
-    }
-
-    const rawId = ctx.request.url.split("/models/", 2)[1]?.split("?", 1)[0];
-    if (!rawId) {
-      return toModels(ctx.models);
-    }
-
-    let modelId = rawId;
-    try {
-      modelId = decodeURIComponent(rawId);
-    } catch {
-      throw new GatewayError(`Invalid model ID: '${modelId}'`, 400);
-    }
-
-    const model = ctx.models[modelId];
-    if (!model) {
-      throw new GatewayError(`Model not found: '${modelId}'`, 404);
-    }
-
-    return toModel(modelId, model);
-  };
-
-  return { handler: winterCgHandler(handler, config) };
-};

package/src/endpoints/models/index.ts

@@ -1,3 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";

package/src/endpoints/models/schema.ts

@@ -1,37 +0,0 @@
-import * as z from "zod";
-
-export const ModelSchema = z.looseObject({
-  // Core
-  id: z.string(),
-  object: z.literal("model"),
-  created: z.int().nonnegative(),
-  owned_by: z.string(),
-  // Extensions
-  name: z.string().optional().meta({ extension: true }),
-  knowledge: z.string().optional().meta({ extension: true }),
-  context: z.int().nonnegative().optional().meta({ extension: true }),
-  architecture: z
-    .object({
-      modality: z.string().optional(),
-      input_modalities: z.array(z.string()).readonly().optional(),
-      output_modalities: z.array(z.string()).readonly().optional(),
-    })
-    .optional()
-    .meta({ extension: true }),
-  endpoints: z
-    .array(
-      z.object({
-        tag: z.string(),
-      }),
-    )
-    .optional()
-    .meta({ extension: true }),
-  capabilities: z.array(z.string()).readonly().optional().meta({ extension: true }),
-});
-export type Model = z.infer<typeof ModelSchema>;
-
-export const ModelListSchema = z.object({
-  object: z.literal("list"),
-  data: z.array(ModelSchema),
-});
-export type ModelList = z.infer<typeof ModelListSchema>;

package/src/errors/ai-sdk.ts

@@ -1,99 +0,0 @@
-import {
-  AISDKError,
-  APICallError,
-  DownloadError,
-  EmptyResponseBodyError,
-  InvalidArgumentError,
-  InvalidDataContentError,
-  InvalidMessageRoleError,
-  InvalidPromptError,
-  InvalidResponseDataError,
-  InvalidStreamPartError,
-  InvalidToolApprovalError,
-  InvalidToolInputError,
-  JSONParseError,
-  LoadAPIKeyError,
-  LoadSettingError,
-  MessageConversionError,
-  MissingToolResultsError,
-  NoContentGeneratedError,
-  NoImageGeneratedError,
-  NoObjectGeneratedError,
-  NoOutputGeneratedError,
-  NoSpeechGeneratedError,
-  NoSuchModelError,
-  NoSuchProviderError,
-  NoSuchToolError,
-  NoTranscriptGeneratedError,
-  NoVideoGeneratedError,
-  RetryError,
-  ToolCallNotFoundForApprovalError,
-  ToolCallRepairError,
-  TooManyEmbeddingValuesForCallError,
-  TypeValidationError,
-  UIMessageStreamError,
-  UnsupportedModelVersionError,
-  UnsupportedFunctionalityError,
-} from "ai";
-
-import { GatewayError } from "./gateway";
-import { STATUS_CODE } from "./utils";
-
-export const normalizeAiSdkError = (error: unknown): GatewayError | undefined => {
-  if (APICallError.isInstance(error)) {
-    const status = error.statusCode ?? (error.isRetryable ? 502 : 422);
-    const code = `UPSTREAM_${STATUS_CODE(status)}`;
-    return new GatewayError(error, status, code);
-  }
-
-  if (
-    JSONParseError.isInstance(error) ||
-    InvalidResponseDataError.isInstance(error) ||
-    TypeValidationError.isInstance(error) ||
-    EmptyResponseBodyError.isInstance(error) ||
-    NoContentGeneratedError.isInstance(error) ||
-    NoOutputGeneratedError.isInstance(error) ||
-    InvalidStreamPartError.isInstance(error) ||
-    UIMessageStreamError.isInstance(error) ||
-    RetryError.isInstance(error) ||
-    DownloadError.isInstance(error) ||
-    ToolCallRepairError.isInstance(error) ||
-    NoImageGeneratedError.isInstance(error) ||
-    NoObjectGeneratedError.isInstance(error) ||
-    NoSpeechGeneratedError.isInstance(error) ||
-    NoTranscriptGeneratedError.isInstance(error) ||
-    NoVideoGeneratedError.isInstance(error)
-  ) {
-    return new GatewayError(error, 502, `UPSTREAM_${STATUS_CODE(502)}`);
-  }
-
-  if (
-    InvalidArgumentError.isInstance(error) ||
-    InvalidPromptError.isInstance(error) ||
-    InvalidMessageRoleError.isInstance(error) ||
-    InvalidDataContentError.isInstance(error) ||
-    MessageConversionError.isInstance(error) ||
-    InvalidToolInputError.isInstance(error) ||
-    InvalidToolApprovalError.isInstance(error) ||
-    ToolCallNotFoundForApprovalError.isInstance(error) ||
-    MissingToolResultsError.isInstance(error) ||
-    NoSuchToolError.isInstance(error) ||
-    UnsupportedModelVersionError.isInstance(error) ||
-    UnsupportedFunctionalityError.isInstance(error) ||
-    TooManyEmbeddingValuesForCallError.isInstance(error) ||
-    NoSuchModelError.isInstance(error) ||
-    NoSuchProviderError.isInstance(error)
-  ) {
-    return new GatewayError(error, 422, `UPSTREAM_${STATUS_CODE(422)}`);
-  }
-
-  if (LoadSettingError.isInstance(error) || LoadAPIKeyError.isInstance(error)) {
-    return new GatewayError(error, 500);
-  }
-
-  if (AISDKError.isInstance(error)) {
-    return new GatewayError(error, 500);
-  }
-
-  return undefined;
-};

package/src/errors/gateway.ts

@@ -1,17 +0,0 @@
-import { STATUS_CODE } from "./utils";
-
-export class GatewayError extends Error {
-  readonly status: number;
-  readonly code: string;
-
-  constructor(error: unknown, status: number, code?: string, cause?: unknown) {
-    const isError = error instanceof Error;
-    super(isError ? error.message : String(error));
-
-    this.name = "GatewayError";
-    this.cause = cause ?? (isError ? error : undefined);
-
-    this.status = status;
-    this.code = code ?? STATUS_CODE(status);
-  }
-}

package/src/errors/openai.ts

@@ -1,57 +0,0 @@
-import * as z from "zod";
-
-import { isProduction } from "../utils/env";
-import { resolveRequestId } from "../utils/headers";
-import { toResponse } from "../utils/response";
-import { getErrorMeta, STATUS_CODE } from "./utils";
-
-export const OpenAIErrorSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string(),
-    code: z.string().optional().nullable(),
-    param: z.string().optional().nullable(),
-  }),
-});
-
-export class OpenAIError {
-  readonly error;
-
-  constructor(message: string, type: string = "server_error", code?: string, param: string = "") {
-    this.error = { message, type, code: code?.toLowerCase(), param };
-  }
-}
-
-const mapType = (status: number) => (status < 500 ? "invalid_request_error" : "server_error");
-
-const maybeMaskMessage = (meta: ReturnType<typeof getErrorMeta>, requestId?: string) => {
-  // FUTURE: consider masking all upstream errors, also 4xx
-  if (!(isProduction() && meta.status >= 500)) {
-    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(maybeMaskMessage(meta), mapType(meta.status), meta.code);
-}
-
-export function toOpenAIErrorResponse(error: unknown, responseInit?: ResponseInit) {
-  const meta = getErrorMeta(error);
-
-  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

@@ -1,47 +0,0 @@
-import { normalizeAiSdkError } from "./ai-sdk";
-import { GatewayError } from "./gateway";
-
-export const STATUS_CODES = {
-  400: "BAD_REQUEST",
-  401: "UNAUTHORIZED",
-  402: "PAYMENT_REQUIRED",
-  403: "FORBIDDEN",
-  404: "NOT_FOUND",
-  405: "METHOD_NOT_ALLOWED",
-  409: "CONFLICT",
-  422: "UNPROCESSABLE_ENTITY",
-  429: "TOO_MANY_REQUESTS",
-  499: "CLIENT_CLOSED_REQUEST",
-  500: "INTERNAL_SERVER_ERROR",
-  502: "BAD_GATEWAY",
-  503: "SERVICE_UNAVAILABLE",
-  504: "GATEWAY_TIMEOUT",
-} as const;
-
-export const STATUS_CODE = (status: number) => {
-  const label = STATUS_CODES[status as keyof typeof STATUS_CODES];
-  if (label) return label;
-  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 status: number;
-  let code: string;
-
-  if (error instanceof GatewayError) {
-    ({ status, code } = error);
-  } else {
-    const normalized = normalizeAiSdkError(error);
-    if (normalized) {
-      ({ status, code } = normalized);
-    } else {
-      status = 500;
-      code = STATUS_CODE(status);
-    }
-  }
-
-  return { status, code, message };
-}

package/src/gateway.ts

@@ -1,50 +0,0 @@
-import type { Endpoint, GatewayConfig, HeboGateway } from "./types";
-
-import { parseConfig } from "./config";
-import { chatCompletions } from "./endpoints/chat-completions/handler";
-import { embeddings } from "./endpoints/embeddings/handler";
-import { models } from "./endpoints/models/handler";
-import { GatewayError } from "./errors/gateway";
-import { winterCgHandler } from "./lifecycle";
-import { logger } from "./logger";
-
-let inflight = 0;
-
-export function gateway(config: GatewayConfig) {
-  const basePath = (config.basePath ?? "").replace(/\/+$/, "");
-  const parsedConfig = parseConfig(config);
-
-  const notFoundHandler = winterCgHandler(() => {
-    throw new GatewayError("Not Found", 404);
-  }, parsedConfig);
-
-  const routes = {
-    ["/chat/completions"]: chatCompletions(parsedConfig),
-    ["/embeddings"]: embeddings(parsedConfig),
-    ["/models"]: models(parsedConfig),
-  } as const satisfies Record<string, Endpoint>;
-
-  const routeEntries = Object.entries(routes);
-
-  const handler = (req: Request, state?: Record<string, unknown>): Promise<Response> => {
-    let pathname = new URL(req.url).pathname;
-    if (basePath && pathname.startsWith(basePath)) {
-      pathname = pathname.slice(basePath.length);
-    }
-
-    logger.info(`[gateway] ${req.method} ${pathname} (${++inflight})`);
-    for (const [route, endpoint] of routeEntries) {
-      if (pathname === route || pathname.startsWith(route + "/")) {
-        try {
-          return endpoint.handler(req, state);
-        } finally {
-          inflight--;
-        }
-      }
-    }
-
-    return notFoundHandler(req, state);
-  };
-
-  return { handler, routes } satisfies HeboGateway<typeof routes>;
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-export * from "./gateway";
-export type * from "./types";
-
-export * from "./errors/gateway";
-export * from "./errors/openai";
-export * from "./logger";
-
-export * from "./middleware/common";
-export * from "./middleware/matcher";
-
-export * from "./endpoints/chat-completions";
-export * from "./endpoints/embeddings";
-export * from "./endpoints/models";
-
-export * from "./models/catalog";
-export * from "./models/types";
-
-export * from "./providers/registry";
-export * from "./providers/types";