@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/middleware/matcher.ts

@@ -1,161 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-
-import type { ModelId } from "../models/types";
-import type { ProviderId } from "../providers/types";
-
-import { logger } from "../logger";
-import { addSpanEvent } from "../telemetry/span";
-import { forwardParamsEmbeddingMiddleware, forwardParamsMiddleware } from "./common";
-import { debugEmbeddingFinalParamsMiddleware, debugFinalParamsMiddleware } from "./debug";
-
-type MiddlewareEntries = {
-  language?: LanguageModelMiddleware[];
-  embedding?: EmbeddingModelMiddleware[];
-};
-
-type Rule = {
-  pattern: string;
-  test: (key: string) => boolean;
-  stored: MiddlewareEntries;
-};
-
-type ModelMiddleware = LanguageModelMiddleware | EmbeddingModelMiddleware;
-
-class SimpleMatcher {
-  private rules: Rule[] = [];
-
-  use(pattern: string, entry: MiddlewareEntries) {
-    const stored: MiddlewareEntries = {
-      language: entry.language ? [...entry.language] : undefined,
-      embedding: entry.embedding ? [...entry.embedding] : undefined,
-    };
-
-    this.rules.push({ pattern, test: compilePattern(pattern), stored });
-  }
-
-  match(key: string): MiddlewareEntries[] {
-    const out: MiddlewareEntries[] = [];
-    const matched: string[] = [];
-    for (const r of this.rules) {
-      if (!r.test(key)) continue;
-      out.push(r.stored);
-      matched.push(r.pattern);
-    }
-    const matchedSummary = matched.length > 0 ? matched.join(",") : "none";
-    logger.debug(`[middleware] matched ${key} to [${matchedSummary}]`);
-    return out;
-  }
-}
-
-class ModelMiddlewareMatcher {
-  private model = new SimpleMatcher();
-  private provider = new SimpleMatcher();
-
-  private static readonly MAX_CACHE = 500;
-  private cache = new Map<string, ModelMiddleware[]>();
-
-  useForModel(patterns: ModelId | readonly ModelId[], entry: MiddlewareEntries) {
-    this.cache.clear();
-    for (const pattern of toArray(patterns)) {
-      this.model.use(pattern, entry);
-    }
-  }
-
-  useForProvider(patterns: ProviderId | readonly ProviderId[], entry: MiddlewareEntries) {
-    this.cache.clear();
-    for (const pattern of toArray(patterns)) {
-      this.provider.use(pattern, entry);
-    }
-  }
-
-  for(modelId: ModelId, providerId: ProviderId): LanguageModelMiddleware[] {
-    return this.resolve({
-      kind: "text",
-      modelId,
-      providerId,
-      forward: () => forwardParamsMiddleware(providerId),
-      debug: debugFinalParamsMiddleware,
-    }) as LanguageModelMiddleware[];
-  }
-
-  forEmbedding(modelId: ModelId, providerId: ProviderId): EmbeddingModelMiddleware[] {
-    return this.resolve({
-      kind: "embedding",
-      modelId,
-      providerId,
-      forward: () => forwardParamsEmbeddingMiddleware(providerId),
-      debug: debugEmbeddingFinalParamsMiddleware,
-    }) as EmbeddingModelMiddleware[];
-  }
-
-  resolve(options: {
-    kind: "text" | "embedding";
-    modelId?: ModelId;
-    providerId?: ProviderId;
-    forward?: ModelMiddleware | (() => ModelMiddleware);
-    debug?: ModelMiddleware;
-  }): ModelMiddleware[] {
-    const { kind, modelId, providerId, forward, debug } = options;
-
-    const key = `${kind}-${modelId}:${providerId}`;
-    const cached = this.cache.get(key);
-    if (cached) {
-      logger.debug(`[middleware] cache hit for ${modelId}:${providerId}`);
-      return cached;
-    }
-
-    const out: ModelMiddleware[] = [];
-    if (modelId) {
-      out.push(...this.collect(this.model.match(modelId), kind));
-    }
-    if (forward) {
-      out.push(typeof forward === "function" ? forward() : forward);
-    }
-    if (providerId) {
-      out.push(...this.collect(this.provider.match(providerId), kind));
-    }
-    if (debug) {
-      out.push(debug);
-    }
-
-    if (this.cache.size >= ModelMiddlewareMatcher.MAX_CACHE) {
-      let n = Math.ceil(ModelMiddlewareMatcher.MAX_CACHE * 0.2);
-      for (const cacheKey of this.cache.keys()) {
-        this.cache.delete(cacheKey);
-        if (--n === 0) break;
-      }
-      logger.warn(`[middleware] cache eviction`);
-      addSpanEvent("hebo.middleware.cache.evicted");
-    }
-
-    this.cache.set(key, out);
-    return out;
-  }
-
-  private collect(entries: MiddlewareEntries[], kind: "text" | "embedding"): ModelMiddleware[] {
-    const out: ModelMiddleware[] = [];
-    for (const s of entries) {
-      if (kind === "text") out.push(...(s.language ?? []));
-      else out.push(...(s.embedding ?? []));
-    }
-    return out;
-  }
-}
-
-export const modelMiddlewareMatcher = new ModelMiddlewareMatcher();
-export type { ModelMiddlewareMatcher };
-
-const toArray = <T>(v: T | readonly T[]) => (Array.isArray(v) ? v : [v]);
-
-function compilePattern(pattern: string): (key: string) => boolean {
-  if (!pattern.includes("*")) return (key) => key === pattern;
-
-  const re = new RegExp(
-    `^${pattern
-      .split("*")
-      .map((p) => p.replaceAll(/[-\\^$+?.()|[\]{}]/g, "\\$&"))
-      .join(".*")}$`,
-  );
-
-  return (key) => re.test(key);
-}

package/src/middleware/utils.ts

@@ -1,34 +0,0 @@
-import type { ChatCompletionsReasoningEffort } from "../endpoints/chat-completions/schema";
-
-export function calculateReasoningBudgetFromEffort(
-  effort: ChatCompletionsReasoningEffort,
-  maxTokens: number,
-  minTokens: number = 1024,
-): number {
-  let percentage = 0;
-  switch (effort) {
-    case "none":
-      percentage = 0;
-      break;
-    case "minimal":
-      percentage = 0.1;
-      break;
-    case "low":
-      percentage = 0.2;
-      break;
-    case "medium":
-      percentage = 0.5;
-      break;
-    case "high":
-      percentage = 0.8;
-      break;
-    case "xhigh":
-    case "max":
-      percentage = 0.95;
-      break;
-    default:
-      return 0;
-  }
-
-  return Math.max(minTokens, Math.floor(maxTokens * percentage));
-}

package/src/models/amazon/index.ts

@@ -1,2 +0,0 @@
-export * from "./middleware";
-export * from "./presets";

package/src/models/amazon/middleware.test.ts

@@ -1,133 +0,0 @@
-import { MockLanguageModelV3 } from "ai/test";
-import { expect, test } from "bun:test";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { CANONICAL_MODEL_IDS } from "../../models/types";
-import { novaDimensionsMiddleware, novaReasoningMiddleware } from "./middleware";
-
-test("nova middleware > matching patterns", () => {
-  const languageMatching = ["amazon/nova-2-lite"] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const languageNonMatching = [
-    "amazon/nova-micro",
-    "amazon/nova-lite",
-    "amazon/nova-pro",
-    "amazon/nova-premier",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of languageMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).toContain(novaReasoningMiddleware);
-  }
-
-  for (const id of languageNonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).not.toContain(novaReasoningMiddleware);
-  }
-
-  const embeddingMatching = [
-    "amazon/nova-2-multimodal-embeddings",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const embeddingNonMatching = [
-    "amazon/nova-2-lite",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of embeddingMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).toContain(novaDimensionsMiddleware);
-  }
-
-  for (const id of embeddingNonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).not.toContain(novaDimensionsMiddleware);
-  }
-});
-
-test("novaReasoningMiddleware > should map effort to Bedrock reasoning config", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true, effort: "low" },
-      },
-    },
-  };
-
-  const result = await novaReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3(),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      amazon: {
-        reasoningConfig: {
-          type: "enabled",
-          maxReasoningEffort: "low",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("novaReasoningMiddleware > should disable reasoning when requested", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false },
-      },
-    },
-  };
-
-  const result = await novaReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3(),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      amazon: {
-        reasoningConfig: {
-          type: "disabled",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("novaReasoningMiddleware > should default reasoning effort when enabled without effort", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true },
-      },
-    },
-  };
-
-  const result = await novaReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3(),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      amazon: {
-        reasoningConfig: {
-          type: "enabled",
-        },
-      },
-      unknown: {},
-    },
-  });
-});

package/src/models/amazon/middleware.ts

@@ -1,79 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-
-import type {
-  ChatCompletionsReasoningConfig,
-  ChatCompletionsReasoningEffort,
-} from "../../endpoints/chat-completions/schema";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-
-// Convert `dimensions` (OpenAI) to `embeddingDimension` (Nova)
-export const novaDimensionsMiddleware: EmbeddingModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const dimensions = unknown["dimensions"] as number;
-    if (!dimensions) return params;
-
-    (params.providerOptions!["nova"] ??= {})["embeddingDimension"] = dimensions;
-    delete unknown["dimensions"];
-
-    return params;
-  },
-};
-
-function mapNovaEffort(effort: ChatCompletionsReasoningEffort) {
-  switch (effort) {
-    case "minimal":
-    case "low":
-      return "low";
-    case "medium":
-      return "medium";
-    case "high":
-    case "xhigh":
-    case "max":
-      return "high";
-  }
-}
-
-export const novaReasoningMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const reasoning = unknown["reasoning"] as ChatCompletionsReasoningConfig;
-    if (!reasoning) return params;
-
-    const target = (params.providerOptions!["amazon"] ??= {});
-
-    if (!reasoning.enabled) {
-      target["reasoningConfig"] = { type: "disabled" };
-    } else if (reasoning.effort) {
-      // FUTURE: warn if mapNovaEffort modified the effort
-      target["reasoningConfig"] = {
-        type: "enabled",
-        maxReasoningEffort: mapNovaEffort(reasoning.effort),
-      };
-    } else {
-      // FUTURE: warn if reasoning.max_tokens (unsupported) was ignored
-      target["reasoningConfig"] = { type: "enabled" };
-    }
-
-    delete unknown["reasoning"];
-
-    return params;
-  },
-};
-
-modelMiddlewareMatcher.useForModel("amazon/nova-*embeddings*", {
-  embedding: [novaDimensionsMiddleware],
-});
-
-modelMiddlewareMatcher.useForModel("amazon/nova-2-*", {
-  language: [novaReasoningMiddleware],
-});

package/src/models/amazon/presets.ts

@@ -1,104 +0,0 @@
-import type { CanonicalProviderId } from "../../providers/types";
-import type { CanonicalModelId, CatalogModel } from "../types";
-
-import { presetFor, type DeepPartial } from "../../utils/preset";
-
-const NOVA_TEXT_BASE = {
-  modalities: {
-    input: ["text"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["tool_call", "temperature"] as const,
-  providers: ["bedrock"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-const NOVA_MULTIMODAL_BASE = {
-  modalities: {
-    input: ["text", "image", "video", "pdf"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["attachments", "tool_call", "temperature"] as const,
-  providers: ["bedrock"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-const NOVA_EMBEDDINGS_BASE = {
-  modalities: {
-    input: ["text", "image", "audio", "video", "pdf"] as const,
-    output: ["embedding"] as const,
-  },
-  providers: ["bedrock"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-export const novaMicro = presetFor<CanonicalModelId, CatalogModel>()("amazon/nova-micro" as const, {
-  ...NOVA_TEXT_BASE,
-  name: "Amazon Nova Micro",
-  created: "2024-12-03",
-  knowledge: "2024-10",
-  context: 128000,
-} satisfies CatalogModel);
-
-export const novaLite = presetFor<CanonicalModelId, CatalogModel>()("amazon/nova-lite" as const, {
-  ...NOVA_MULTIMODAL_BASE,
-  name: "Amazon Nova Lite",
-  created: "2024-12-03",
-  knowledge: "2024-10",
-  context: 300000,
-} satisfies CatalogModel);
-
-export const novaPro = presetFor<CanonicalModelId, CatalogModel>()("amazon/nova-pro" as const, {
-  ...NOVA_MULTIMODAL_BASE,
-  name: "Amazon Nova Pro",
-  created: "2024-12-03",
-  knowledge: "2024-10",
-  context: 300000,
-} satisfies CatalogModel);
-
-export const novaPremier = presetFor<CanonicalModelId, CatalogModel>()(
-  "amazon/nova-premier" as const,
-  {
-    ...NOVA_MULTIMODAL_BASE,
-    name: "Amazon Nova Premier",
-    created: "2024-12-03",
-    knowledge: "2024-10",
-    context: 1000000,
-  } satisfies CatalogModel,
-);
-
-export const nova2Lite = presetFor<CanonicalModelId, CatalogModel>()(
-  "amazon/nova-2-lite" as const,
-  {
-    ...NOVA_TEXT_BASE,
-    name: "Amazon Nova 2 Lite",
-    created: "2025-12-01",
-    knowledge: "2024-10",
-    context: 128000,
-  } satisfies CatalogModel,
-);
-
-export const nova2MultimodalEmbeddings = presetFor<CanonicalModelId, CatalogModel>()(
-  "amazon/nova-2-multimodal-embeddings" as const,
-  {
-    ...NOVA_EMBEDDINGS_BASE,
-    name: "Amazon Nova Multimodal Embeddings",
-    created: "2025-10-28",
-    context: 8000,
-  } satisfies CatalogModel,
-);
-
-const novaAtomic = {
-  v1: [novaMicro, novaLite, novaPro, novaPremier],
-  v2: [nova2Lite, nova2MultimodalEmbeddings],
-} as const;
-
-const novaGroups = {
-  "v1.x": [...novaAtomic["v1"]],
-  "v2.x": [...novaAtomic["v2"]],
-} as const;
-
-export const nova = {
-  ...novaAtomic,
-  ...novaGroups,
-  latest: [...novaAtomic["v1"], ...novaAtomic["v2"]],
-  embeddings: [nova2MultimodalEmbeddings],
-  all: Object.values(novaAtomic).flat(),
-} as const;

package/src/models/anthropic/index.ts

@@ -1,2 +0,0 @@
-export * from "./presets";
-export * from "./middleware";