@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/models/cohere/presets.ts

@@ -1,186 +0,0 @@
-import type { CanonicalProviderId } from "../../providers/types";
-import type { CanonicalModelId, CatalogModel } from "../types";
-
-import { presetFor, type DeepPartial } from "../../utils/preset";
-
-const COMMAND_BASE = {
-  modalities: {
-    input: ["text"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["tool_call", "structured_output", "reasoning", "temperature"] as const,
-  providers: ["cohere"] as const satisfies readonly CanonicalProviderId[],
-  knowledge: "2024-06",
-} satisfies DeepPartial<CatalogModel>;
-
-const COMMAND_VISION_BASE = {
-  modalities: {
-    input: ["text", "image"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["structured_output", "reasoning", "temperature"] as const,
-  providers: ["cohere"] as const satisfies readonly CanonicalProviderId[],
-  knowledge: "2024-06",
-} satisfies DeepPartial<CatalogModel>;
-
-const EMBED_V3_BASE = {
-  modalities: {
-    input: ["text", "image"] as const,
-    output: ["embedding"] as const,
-  },
-  providers: ["cohere"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-const EMBED_V4_BASE = {
-  modalities: {
-    input: ["text", "image", "pdf"] as const,
-    output: ["embedding"] as const,
-  },
-  providers: ["cohere"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-export const commandA = presetFor<CanonicalModelId, CatalogModel>()("cohere/command-a" as const, {
-  ...COMMAND_BASE,
-  name: "Cohere Command A",
-  created: "2025-03-13",
-  context: 256000,
-} satisfies CatalogModel);
-
-export const commandAReasoning = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/command-a-reasoning" as const,
-  {
-    ...COMMAND_BASE,
-    name: "Cohere Command A Reasoning",
-    created: "2025-08-21",
-    context: 256000,
-  } satisfies CatalogModel,
-);
-
-export const commandATranslate = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/command-a-translate" as const,
-  {
-    ...COMMAND_BASE,
-    name: "Cohere Command A Translate",
-    created: "2025-08-28",
-    context: 8000,
-  } satisfies CatalogModel,
-);
-
-export const commandAVision = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/command-a-vision" as const,
-  {
-    ...COMMAND_VISION_BASE,
-    name: "Cohere Command A Vision",
-    created: "2025-07-31",
-    context: 128000,
-  } satisfies CatalogModel,
-);
-
-export const commandR = presetFor<CanonicalModelId, CatalogModel>()("cohere/command-r" as const, {
-  ...COMMAND_BASE,
-  name: "Cohere Command R",
-  created: "2024-08-01",
-  context: 128000,
-  providers: ["cohere", "bedrock"],
-} satisfies CatalogModel);
-
-export const commandRPlus = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/command-r-plus" as const,
-  {
-    ...COMMAND_BASE,
-    name: "Cohere Command R+",
-    created: "2024-08-01",
-    context: 128000,
-    providers: ["cohere", "bedrock"],
-  } satisfies CatalogModel,
-);
-
-export const commandR7b = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/command-r7b" as const,
-  {
-    ...COMMAND_BASE,
-    name: "Cohere Command R7B",
-    created: "2024-12-13",
-    context: 128000,
-  } satisfies CatalogModel,
-);
-
-export const embed4 = presetFor<CanonicalModelId, CatalogModel>()("cohere/embed-v4.0" as const, {
-  ...EMBED_V4_BASE,
-  name: "Cohere 4 Embeddings",
-  created: "2025-04-15",
-  context: 128000,
-  providers: ["cohere", "bedrock"],
-} satisfies CatalogModel);
-
-export const embedEnglishV3 = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/embed-english-v3.0" as const,
-  {
-    ...EMBED_V3_BASE,
-    name: "Cohere Embed English v3",
-    created: "2024-02-07",
-    context: 512,
-    providers: ["cohere", "bedrock"],
-  } satisfies CatalogModel,
-);
-
-export const embedEnglishLightV3 = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/embed-english-light-v3.0" as const,
-  {
-    ...EMBED_V3_BASE,
-    name: "Cohere Embed English Light v3",
-    created: "2024-02-07",
-    context: 512,
-    providers: ["cohere"],
-  } satisfies CatalogModel,
-);
-
-export const embedMultilingualV3 = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/embed-multilingual-v3.0" as const,
-  {
-    ...EMBED_V3_BASE,
-    name: "Cohere Embed Multilingual v3",
-    created: "2024-02-07",
-    context: 512,
-    providers: ["cohere", "bedrock"],
-  } satisfies CatalogModel,
-);
-
-export const embedMultilingualLightV3 = presetFor<CanonicalModelId, CatalogModel>()(
-  "cohere/embed-multilingual-light-v3.0" as const,
-  {
-    ...EMBED_V3_BASE,
-    name: "Cohere Embed Multilingual Light v3",
-    created: "2024-02-07",
-    context: 512,
-    providers: ["cohere"],
-  } satisfies CatalogModel,
-);
-
-const commandAtomic = {
-  A: [commandA, commandAReasoning, commandATranslate, commandAVision],
-  R: [commandR, commandRPlus, commandR7b],
-} as const;
-
-const commandGroups = {} as const;
-
-export const command = {
-  ...commandAtomic,
-  ...commandGroups,
-  latest: [commandA],
-  all: Object.values(commandAtomic).flat(),
-} as const;
-
-const embedAtomic = {
-  v4: [embed4],
-  v3: [embedEnglishV3, embedEnglishLightV3, embedMultilingualV3, embedMultilingualLightV3],
-} as const;
-
-const embedGroups = {} as const;
-
-export const embed = {
-  ...embedAtomic,
-  ...embedGroups,
-  latest: [embed4],
-  all: Object.values(embedAtomic).flat(),
-} as const;

package/src/models/google/index.ts

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

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

@@ -1,298 +0,0 @@
-import { MockLanguageModelV3 } from "ai/test";
-import { expect, test } from "bun:test";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
-import { CANONICAL_MODEL_IDS } from "../../models/types";
-import {
-  geminiDimensionsMiddleware,
-  geminiPromptCachingMiddleware,
-  geminiReasoningMiddleware,
-} from "./middleware";
-
-test("geminiReasoningMiddleware > matching patterns", () => {
-  const matching = [
-    "google/gemini-2.5-flash-lite",
-    "google/gemini-2.5-flash",
-    "google/gemini-2.5-pro",
-    "google/gemini-3-flash-preview",
-    "google/gemini-3.1-flash-lite-preview",
-    "google/gemini-3.1-pro-preview",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const nonMatching = ["google/gemini-1.5-pro", "google/gemini-1.5-flash"];
-
-  for (const id of matching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).toContain(geminiReasoningMiddleware);
-    expect(middleware).toContain(geminiPromptCachingMiddleware);
-  }
-
-  for (const id of nonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).not.toContain(geminiReasoningMiddleware);
-  }
-});
-
-test("geminiPromptCachingMiddleware > should map normalized cached_content", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        cached_content: "cachedContents/reusable",
-      },
-    },
-  };
-
-  const result = await geminiPromptCachingMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-2.5-flash" }),
-  });
-
-  expect(result.providerOptions).toEqual({
-    google: {
-      cachedContent: "cachedContents/reusable",
-    },
-    unknown: {},
-  });
-});
-
-test("geminiDimensionsMiddleware > matching patterns", () => {
-  const matching = ["google/gemini-embedding-001"];
-  const nonMatching = [
-    "google/gemini-3-flash-preview",
-    "google/embedding-001",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of matching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).toContain(geminiDimensionsMiddleware);
-  }
-
-  for (const id of nonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).not.toContain(geminiDimensionsMiddleware);
-  }
-});
-
-test("geminiReasoningMiddleware > should enable thinking for Gemini 3 Flash effort", async () => {
-  const params = {
-    prompt: [],
-    maxOutputTokens: 2000,
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true, effort: "medium" },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-3-flash-preview" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    maxOutputTokens: 2000,
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          includeThoughts: true,
-          thinkingLevel: "medium",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("geminiReasoningMiddleware > should map medium effort for Gemini 3.1 Pro", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true, effort: "medium" },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-3.1-pro-preview" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          includeThoughts: true,
-          thinkingLevel: "medium",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("geminiReasoningMiddleware > should normalize none effort for Gemini 3.1 Flash Lite", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false, effort: "none" },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-3.1-flash-lite-preview" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          includeThoughts: false,
-          thinkingLevel: "minimal",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("geminiReasoningMiddleware > should use budget for Gemini 2", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true, effort: "medium" },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-2.5-flash" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          includeThoughts: true,
-          thinkingBudget: calculateReasoningBudgetFromEffort("medium", 65536),
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("geminiReasoningMiddleware > should handle disabled reasoning", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false, effort: "none" },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-3-flash-preview" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          includeThoughts: false,
-          thinkingLevel: "minimal",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("geminiReasoningMiddleware > should default reasoning effort for Gemini 3 Flash", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-3-flash-preview" }),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      google: {
-        thinkingConfig: {
-          includeThoughts: true,
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("geminiReasoningMiddleware > Gemini 2.5 Pro should have minimum budget even if reasoning is disabled", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-2.5-pro" }),
-  });
-
-  expect(result.providerOptions?.google?.thinkingConfig?.thinkingBudget).toBe(128);
-  expect(result.providerOptions?.google?.thinkingConfig?.includeThoughts).toBe(false);
-});
-
-test("geminiReasoningMiddleware > Gemini 2.0 Flash should NOT have forced minimum budget", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false, effort: "none" },
-      },
-    },
-  };
-
-  const result = await geminiReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "google/gemini-2.0-flash" }),
-  });
-
-  expect(result.providerOptions?.google?.thinkingConfig?.thinkingBudget).toBe(0);
-  expect(result.providerOptions?.google?.thinkingConfig?.includeThoughts).toBe(false);
-});

package/src/models/google/middleware.ts

@@ -1,137 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-
-import type {
-  ChatCompletionsReasoningConfig,
-  ChatCompletionsReasoningEffort,
-} from "../../endpoints/chat-completions/schema";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
-
-// Convert `dimensions` (OpenAI) to `outputDimensionality` (Google)
-export const geminiDimensionsMiddleware: 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!["google"] ??= {})["outputDimensionality"] = dimensions;
-    delete unknown["dimensions"];
-
-    return params;
-  },
-};
-
-// https://ai.google.dev/gemini-api/docs/thinking#thinking-levels
-export function mapGeminiReasoningEffort(
-  effort: ChatCompletionsReasoningEffort,
-  modelId: string,
-): ChatCompletionsReasoningEffort | undefined {
-  if (modelId.includes("gemini-3.1-pro")) {
-    switch (effort) {
-      case "none":
-      case "minimal":
-      case "low":
-        return "low";
-      case "medium":
-        return "medium";
-      case "high":
-      case "xhigh":
-      case "max":
-        return "high";
-    }
-  }
-
-  if (modelId.includes("gemini-3-flash") || modelId.includes("gemini-3.1-flash")) {
-    switch (effort) {
-      case "none":
-      case "minimal":
-        return "minimal";
-      case "low":
-        return "low";
-      case "medium":
-        return "medium";
-      case "high":
-      case "xhigh":
-      case "max":
-        return "high";
-    }
-  }
-
-  return effort;
-}
-
-export const GEMINI_DEFAULT_MAX_OUTPUT_TOKENS = 65536;
-export const GEMINI_2_5_PRO_MIN_THINKING_BUDGET = 128;
-
-export const geminiReasoningMiddleware: 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!["google"] ??= {});
-    const modelId = model.modelId;
-
-    if (modelId.includes("gemini-2")) {
-      const is25Pro = modelId.includes("gemini-2.5-pro");
-
-      target["thinkingConfig"] = {
-        thinkingBudget:
-          reasoning.max_tokens ??
-          calculateReasoningBudgetFromEffort(
-            reasoning.effort ?? "none",
-            params.maxOutputTokens ?? GEMINI_DEFAULT_MAX_OUTPUT_TOKENS,
-            is25Pro ? GEMINI_2_5_PRO_MIN_THINKING_BUDGET : 0,
-          ),
-      };
-    } else if (modelId.includes("gemini-3") && reasoning.effort) {
-      target["thinkingConfig"] = {
-        thinkingLevel: mapGeminiReasoningEffort(reasoning.effort, modelId),
-      };
-      // FUTURE: warn if model is gemini-3 and max_tokens (unsupported) was ignored
-    }
-
-    ((target["thinkingConfig"] ??= {}) as Record<string, unknown>)["includeThoughts"] =
-      reasoning.enabled ? !reasoning.exclude : false;
-
-    delete unknown["reasoning"];
-
-    return params;
-  },
-};
-
-// https://ai.google.dev/gemini-api/docs/caching
-// FUTURE: auto-create cached_content for message-level cache_control blocks
-export const geminiPromptCachingMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const cachedContent = unknown["cached_content"] as string | undefined;
-    if (cachedContent) {
-      (params.providerOptions!["google"] ??= {})["cachedContent"] = cachedContent;
-    }
-
-    delete unknown["cached_content"];
-    return params;
-  },
-};
-
-modelMiddlewareMatcher.useForModel("google/gemini-*embedding-*", {
-  embedding: [geminiDimensionsMiddleware],
-});
-
-modelMiddlewareMatcher.useForModel(["google/gemini-2*", "google/gemini-3*"], {
-  language: [geminiReasoningMiddleware, geminiPromptCachingMiddleware],
-});