@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/models/google/presets.ts

@@ -1,118 +0,0 @@
-import type { CanonicalProviderId } from "../../providers/types";
-import type { CanonicalModelId, CatalogModel } from "../types";
-
-import { presetFor, type DeepPartial } from "../../utils/preset";
-
-const GEMINI_BASE = {
-  modalities: {
-    input: ["text", "image", "pdf", "file", "audio", "video"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: [
-    "attachments",
-    "reasoning",
-    "tool_call",
-    "structured_output",
-    "temperature",
-  ] as const,
-  context: 1048576,
-  providers: ["vertex"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-const GEMINI_EMBEDDINGS_BASE = {
-  modalities: {
-    input: ["text"] as const,
-    output: ["embedding"] as const,
-  },
-  providers: ["vertex"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-export const geminiEmbedding001 = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/embedding-001" as const,
-  {
-    ...GEMINI_EMBEDDINGS_BASE,
-    name: "Gemini Embedding 001",
-    created: "2025-05-20",
-    context: 8192,
-  } satisfies CatalogModel,
-);
-
-export const gemini3FlashPreview = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/gemini-3-flash-preview" as const,
-  {
-    ...GEMINI_BASE,
-    name: "Gemini 3 Flash (Preview)",
-    created: "2025-12-17",
-    knowledge: "2025-01",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const gemini31FlashLitePreview = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/gemini-3.1-flash-lite-preview" as const,
-  {
-    ...GEMINI_BASE,
-    name: "Gemini 3.1 Flash-Lite (Preview)",
-    created: "2026-03-03",
-    knowledge: "2025-01",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const gemini31ProPreview = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/gemini-3.1-pro-preview" as const,
-  {
-    ...GEMINI_BASE,
-    name: "Gemini 3.1 Pro (Preview)",
-    created: "2026-02-19",
-    knowledge: "2025-01",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const gemini25FlashLite = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/gemini-2.5-flash-lite" as const,
-  {
-    ...GEMINI_BASE,
-    name: "Gemini 2.5 Flash Lite",
-    created: "2025-06-17",
-    knowledge: "2025-01",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const gemini25Flash = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/gemini-2.5-flash" as const,
-  {
-    ...GEMINI_BASE,
-    name: "Gemini 2.5 Flash",
-    created: "2025-03-20",
-    knowledge: "2025-01",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const gemini25Pro = presetFor<CanonicalModelId, CatalogModel>()(
-  "google/gemini-2.5-pro" as const,
-  {
-    ...GEMINI_BASE,
-    name: "Gemini 2.5 Pro",
-    created: "2025-03-20",
-    knowledge: "2025-01",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-const geminiAtomic = {
-  "v2.5": [gemini25FlashLite, gemini25Flash, gemini25Pro],
-  "v3-preview": [gemini3FlashPreview, gemini31FlashLitePreview, gemini31ProPreview],
-  embeddings: [geminiEmbedding001],
-} as const;
-
-const geminiGroups = {
-  "v2.x": [...geminiAtomic["v2.5"]],
-  "v3.x": [...geminiAtomic["v3-preview"]],
-} as const;
-
-export const gemini = {
-  ...geminiAtomic,
-  ...geminiGroups,
-  latest: [...geminiAtomic["v2.5"]],
-  preview: [...geminiAtomic["v3-preview"]],
-  embeddings: [...geminiAtomic["embeddings"]],
-  all: Object.values(geminiAtomic).flat(),
-} as const;

package/src/models/meta/index.ts

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

package/src/models/meta/presets.ts

@@ -1,143 +0,0 @@
-import type { CanonicalProviderId } from "../../providers/types";
-import type { CanonicalModelId, CatalogModel } from "../types";
-
-import { presetFor, type DeepPartial } from "../../utils/preset";
-
-const LLAMA_3_BASE = {
-  modalities: {
-    input: ["text", "file"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["attachments", "tool_call", "temperature"] as const,
-  context: 128000,
-  providers: ["groq", "bedrock", "vertex"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-export const llama31_8b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.1-8b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.1 8B",
-    created: "2024-07-23",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama31_70b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.1-70b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.1 70B",
-    created: "2024-07-23",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama31_405b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.1-405b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.1 405B",
-    created: "2024-07-23",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama32_1b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.2-1b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.2 1B",
-    created: "2024-09-25",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama32_3b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.2-3b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.2 3B",
-    created: "2024-09-25",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama32_11b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.2-11b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.2 11B",
-    created: "2024-09-25",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama32_90b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.2-90b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.2 90B",
-    created: "2024-09-25",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-export const llama33_70b = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-3.3-70b" as const,
-  {
-    ...LLAMA_3_BASE,
-    name: "Llama 3.3 70B",
-    created: "2024-12-06",
-    knowledge: "2023-12",
-  } satisfies CatalogModel,
-);
-
-const LLAMA_4_BASE = {
-  modalities: {
-    input: ["text", "image", "file"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["attachments", "tool_call", "temperature"] as const,
-  context: 1000000,
-  providers: ["groq", "vertex", "bedrock"] as const,
-} satisfies DeepPartial<CatalogModel>;
-
-export const llama4Scout = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-4-scout" as const,
-  {
-    ...LLAMA_4_BASE,
-    name: "Llama 4 Scout",
-    created: "2025-08-05",
-    knowledge: "2024-06",
-  } satisfies CatalogModel,
-);
-
-export const llama4Maverick = presetFor<CanonicalModelId, CatalogModel>()(
-  "meta/llama-4-maverick" as const,
-  {
-    ...LLAMA_4_BASE,
-    name: "Llama 4 Maverick",
-    created: "2025-08-05",
-    knowledge: "2024-06",
-  } satisfies CatalogModel,
-);
-
-const llamaAtomic = {
-  "v3.1": [llama31_8b, llama31_70b, llama31_405b],
-  "v3.2": [llama32_1b, llama32_3b, llama32_11b, llama32_90b],
-  "v3.3": [llama33_70b],
-  v4: [llama4Scout, llama4Maverick],
-} as const;
-
-const llamaGroups = {
-  "v3.x": [...llamaAtomic["v3.1"], ...llamaAtomic["v3.2"], ...llamaAtomic["v3.3"]],
-  "v4.x": [...llamaAtomic["v4"]],
-} as const;
-
-export const llama = {
-  ...llamaAtomic,
-  ...llamaGroups,
-  latest: [...llamaAtomic["v4"]],
-  all: Object.values(llamaAtomic).flat(),
-} as const;

package/src/models/openai/index.ts

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

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

@@ -1,189 +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 {
-  openAIDimensionsMiddleware,
-  openAIPromptCachingMiddleware,
-  openAIReasoningMiddleware,
-} from "./middleware";
-
-test("openAI middleware > matching patterns", () => {
-  const languageMatching = [
-    "openai/gpt-5",
-    "openai/gpt-5.2-chat",
-    "openai/gpt-5.3-codex",
-    "openai/gpt-oss-20b",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const languageNonMatching = [
-    "openai/text-embedding-3-small",
-    "anthropic/claude-sonnet-3.7",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of languageMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).toContain(openAIReasoningMiddleware);
-    expect(middleware).toContain(openAIPromptCachingMiddleware);
-  }
-
-  for (const id of languageNonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).not.toContain(openAIReasoningMiddleware);
-  }
-
-  const embeddingMatching = [
-    "openai/text-embedding-3-small",
-    "openai/text-embedding-3-large",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const embeddingNonMatching = ["openai/gpt-5"] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of embeddingMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).toContain(openAIDimensionsMiddleware);
-  }
-
-  for (const id of embeddingNonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).not.toContain(openAIDimensionsMiddleware);
-  }
-});
-
-test("openAIPromptCachingMiddleware > should map key and retention", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        prompt_cache_key: "tenant:shared:legal-v1",
-        prompt_cache_retention: "24h",
-      },
-    },
-  };
-
-  const result = await openAIPromptCachingMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-5" }),
-  });
-
-  expect(result.providerOptions).toEqual({
-    openai: {
-      promptCacheKey: "tenant:shared:legal-v1",
-      promptCacheRetention: "24h",
-    },
-    unknown: {},
-  });
-});
-
-test("openAIReasoningMiddleware > should map reasoning effort to OpenAI provider options", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true, effort: "high" },
-      },
-    },
-  };
-
-  const result = await openAIReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-5" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      openai: {
-        reasoningEffort: "high",
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("openAIReasoningMiddleware > should disable reasoning when requested (standard model)", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false },
-      },
-    },
-  };
-
-  const result = await openAIReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-5" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      openai: {
-        reasoningEffort: "none",
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("openAIReasoningMiddleware > should map reasoning for gpt-oss models", async () => {
-  const cases = [
-    { reasoning: { enabled: false }, expected: "low" },
-    { reasoning: { enabled: true }, expected: "low" },
-    { reasoning: { enabled: true, effort: "none" }, expected: "low" },
-    { reasoning: { enabled: true, effort: "minimal" }, expected: "low" },
-    { reasoning: { enabled: true, effort: "low" }, expected: "low" },
-    { reasoning: { enabled: true, effort: "medium" }, expected: "medium" },
-    { reasoning: { enabled: true, effort: "high" }, expected: "high" },
-    { reasoning: { enabled: true, effort: "xhigh" }, expected: "high" },
-  ] as const;
-
-  await Promise.all(
-    cases.map(async ({ reasoning, expected }) => {
-      const params = {
-        prompt: [],
-        providerOptions: {
-          unknown: { reasoning },
-        },
-      };
-
-      const result = await openAIReasoningMiddleware.transformParams!({
-        type: "generate",
-        params,
-        model: new MockLanguageModelV3({ modelId: "openai/gpt-oss-20b" }),
-      });
-
-      expect(result.providerOptions?.openai.reasoningEffort).toBe(expected);
-    }),
-  );
-});
-
-test("openAIReasoningMiddleware > should default reasoning effort when enabled without effort", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true },
-      },
-    },
-  };
-
-  const result = await openAIReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-5" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      openai: {},
-      unknown: {},
-    },
-  });
-});

package/src/models/openai/middleware.ts

@@ -1,103 +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 `dimensions` (OpenAI)
-export const openAIDimensionsMiddleware: 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!["openai"] ??= {})["dimensions"] = dimensions;
-    delete unknown["dimensions"];
-
-    return params;
-  },
-};
-
-function mapGptOssReasoningEffort(
-  effort?: ChatCompletionsReasoningEffort,
-): "low" | "medium" | "high" {
-  switch (effort) {
-    case "medium":
-      return "medium";
-    case "high":
-    case "xhigh":
-    case "max":
-      return "high";
-    default:
-      return "low";
-  }
-}
-
-export const openAIReasoningMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const reasoning = unknown["reasoning"] as ChatCompletionsReasoningConfig;
-    if (!reasoning) return params;
-
-    const target = (params.providerOptions!["openai"] ??= {});
-    const isGptOss = model.modelId.includes("gpt-oss");
-
-    if (isGptOss) {
-      // FUTURE: warn that unable to disable reasoning for gpt-oss models
-      target["reasoningEffort"] = mapGptOssReasoningEffort(reasoning.effort);
-    } else if (reasoning.enabled === false) {
-      target["reasoningEffort"] = "none";
-    } else if (reasoning.effort) {
-      target["reasoningEffort"] = reasoning.effort;
-    }
-
-    // FUTURE: warn that reasoning.max_tokens (not supported) was ignored
-
-    delete unknown["reasoning"];
-
-    return params;
-  },
-};
-
-// https://developers.openai.com/api/docs/guides/prompt-caching/
-export const openAIPromptCachingMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const key = unknown["prompt_cache_key"] as string | undefined;
-    const retention = unknown["prompt_cache_retention"] as "in_memory" | "24h" | undefined;
-
-    if (key || retention) {
-      const target = (params.providerOptions!["openai"] ??= {});
-      if (key) target["promptCacheKey"] = key;
-      if (retention) target["promptCacheRetention"] = retention;
-    }
-
-    delete unknown["prompt_cache_key"];
-    delete unknown["prompt_cache_retention"];
-
-    return params;
-  },
-};
-
-modelMiddlewareMatcher.useForModel("openai/text-embedding-*", {
-  embedding: [openAIDimensionsMiddleware],
-});
-
-modelMiddlewareMatcher.useForModel("openai/gpt-*", {
-  language: [openAIReasoningMiddleware, openAIPromptCachingMiddleware],
-});