@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/models/anthropic/middleware.ts

@@ -1,148 +0,0 @@
-import type { LanguageModelMiddleware } from "ai";
-
-import type {
-  ChatCompletionsCacheControl,
-  ChatCompletionsReasoningConfig,
-  ChatCompletionsReasoningEffort,
-} from "../../endpoints/chat-completions/schema";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
-
-const isClaude = (family: "opus" | "sonnet" | "haiku", version: string) => {
-  const dashed = version.replace(".", "-");
-
-  return (modelId: string) =>
-    modelId.includes(`claude-${family}-${version}`) ||
-    modelId.includes(`claude-${family}-${dashed}`);
-};
-
-const isClaude4 = (modelId: string) => modelId.includes("claude-") && modelId.includes("-4");
-
-const isOpus46 = isClaude("opus", "4.6");
-const isOpus45 = isClaude("opus", "4.5");
-const isOpus4 = isClaude("opus", "4");
-const isSonnet46 = isClaude("sonnet", "4.6");
-
-export function mapClaudeReasoningEffort(effort: ChatCompletionsReasoningEffort, modelId: string) {
-  if (isOpus46(modelId)) {
-    switch (effort) {
-      case "none":
-      case "minimal":
-      case "low":
-        return "low";
-      case "medium":
-        return "medium";
-      case "high":
-        return "high";
-      case "xhigh":
-      case "max":
-        return "max";
-    }
-  }
-
-  switch (effort) {
-    case "none":
-    case "minimal":
-    case "low":
-      return "low";
-    case "medium":
-      return "medium";
-    case "high":
-    case "xhigh":
-    case "max":
-      return "high";
-  }
-}
-
-function getMaxOutputTokens(modelId: string): number {
-  if (isOpus46(modelId)) return 128_000;
-  if (isOpus45(modelId)) return 64_000;
-  if (isOpus4(modelId)) return 32_000;
-  return 64_000;
-}
-
-// Documentation:
-// https://platform.claude.com/docs/en/build-with-claude/effort
-// https://platform.claude.com/docs/en/build-with-claude/extended-thinking
-// https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking
-export const claudeReasoningMiddleware: 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!["anthropic"] ??= {});
-    const modelId = model.modelId;
-    const clampedMaxTokens =
-      reasoning.max_tokens && Math.min(reasoning.max_tokens, getMaxOutputTokens(modelId));
-
-    if (!reasoning.enabled) {
-      target["thinking"] = { type: "disabled" };
-    } else if (reasoning.effort) {
-      if (isClaude4(modelId)) {
-        target["effort"] = mapClaudeReasoningEffort(reasoning.effort, modelId);
-      }
-
-      if (isOpus46(modelId)) {
-        target["thinking"] = clampedMaxTokens
-          ? { type: "adaptive", budgetTokens: clampedMaxTokens }
-          : { type: "adaptive" };
-      } else if (isSonnet46(modelId)) {
-        target["thinking"] = clampedMaxTokens
-          ? { type: "enabled", budgetTokens: clampedMaxTokens }
-          : { type: "adaptive" };
-      } else {
-        target["thinking"] = { type: "enabled" };
-        if (clampedMaxTokens) {
-          target["thinking"]["budgetTokens"] = clampedMaxTokens;
-        } else {
-          // FUTURE: warn that reasoning.max_tokens was computed
-          target["thinking"]["budgetTokens"] = calculateReasoningBudgetFromEffort(
-            reasoning.effort,
-            params.maxOutputTokens ?? getMaxOutputTokens(modelId),
-            1024,
-          );
-        }
-      }
-    } else if (clampedMaxTokens) {
-      target["thinking"] = {
-        type: "enabled",
-        budgetTokens: clampedMaxTokens,
-      };
-    } else {
-      target["thinking"] = { type: "enabled" };
-    }
-
-    delete unknown["reasoning"];
-
-    return params;
-  },
-};
-
-// https://platform.claude.com/docs/en/build-with-claude/prompt-caching
-export const claudePromptCachingMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const cacheControl = unknown["cache_control"] as ChatCompletionsCacheControl;
-    if (cacheControl) {
-      (params.providerOptions!["anthropic"] ??= {})["cacheControl"] = cacheControl;
-    }
-
-    delete unknown["cache_control"];
-
-    return params;
-  },
-};
-
-modelMiddlewareMatcher.useForModel(["anthropic/claude-*3*7*", "anthropic/claude-*4*"], {
-  language: [claudeReasoningMiddleware, claudePromptCachingMiddleware],
-});

package/src/models/anthropic/presets.ts

@@ -1,191 +0,0 @@
-import type { CanonicalProviderId } from "../../providers/types";
-import type { CanonicalModelId, CatalogModel } from "../types";
-
-import { presetFor, type DeepPartial } from "../../utils/preset";
-
-const CLAUDE_BASE = {
-  modalities: {
-    input: ["text", "image", "file"] as const,
-    output: ["text"] as const,
-  },
-  capabilities: ["attachments", "tool_call", "structured_output", "temperature"],
-  context: 200000,
-  providers: ["anthropic", "bedrock", "vertex"] as const satisfies readonly CanonicalProviderId[],
-} satisfies DeepPartial<CatalogModel>;
-
-const CLAUDE_PDF_MODALITIES = {
-  modalities: {
-    input: ["text", "image", "pdf", "file"] as const,
-    output: ["text"] as const,
-  },
-} satisfies DeepPartial<CatalogModel>;
-
-export const claudeHaiku45 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-haiku-4.5" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Haiku 4.5",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-10-01",
-    knowledge: "2025-07",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeHaiku35 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-haiku-3.5" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Haiku 3.5",
-    created: "2024-10-22",
-    knowledge: "2024-07",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeHaiku3 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-haiku-3" as const,
-  {
-    ...CLAUDE_BASE,
-    name: "Claude Haiku 3",
-    created: "2024-03-07",
-    knowledge: "2023-08",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeSonnet45 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-sonnet-4.5" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Sonnet 4.5",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-09-29",
-    knowledge: "2025-07",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeSonnet46 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-sonnet-4.6" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Sonnet 4.6",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2026-02-17",
-    knowledge: "2025-08",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeSonnet4 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-sonnet-4" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Sonnet 4",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-05-14",
-    knowledge: "2025-03",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeSonnet37 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-sonnet-3.7" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Sonnet 3.7",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-02-19",
-    knowledge: "2024-10",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeSonnet35 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-sonnet-3.5" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Sonnet 3.5",
-    created: "2024-10-22",
-    knowledge: "2024-04",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeOpus45 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-opus-4.5" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Opus 4.5",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-11-01",
-    knowledge: "2025-05",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeOpus46 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-opus-4.6" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Opus 4.6",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2026-02-05",
-    knowledge: "2025-05",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeOpus41 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-opus-4.1" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Opus 4.1",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-08-05",
-    knowledge: "2025-03",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-export const claudeOpus4 = presetFor<CanonicalModelId, CatalogModel>()(
-  "anthropic/claude-opus-4" as const,
-  {
-    ...CLAUDE_BASE,
-    ...CLAUDE_PDF_MODALITIES,
-    name: "Claude Opus 4",
-    capabilities: [...CLAUDE_BASE.capabilities, "reasoning"],
-    created: "2025-05-14",
-    knowledge: "2025-03",
-  } satisfies DeepPartial<CatalogModel>,
-);
-
-const claudeAtomic = {
-  "v4.6": [claudeSonnet46, claudeOpus46],
-  "v4.5": [claudeHaiku45, claudeSonnet45, claudeOpus45],
-  "v4.1": [claudeOpus41],
-  v4: [claudeSonnet4, claudeOpus4],
-  "v3.7": [claudeSonnet37],
-  "v3.5": [claudeSonnet35, claudeHaiku35],
-  v3: [claudeHaiku3],
-  haiku: [claudeHaiku45, claudeHaiku35, claudeHaiku3],
-  sonnet: [claudeSonnet46, claudeSonnet45, claudeSonnet4, claudeSonnet37, claudeSonnet35],
-  opus: [claudeOpus46, claudeOpus45, claudeOpus41, claudeOpus4],
-} as const;
-
-const claudeGroups = {
-  "v4.x": [
-    ...claudeAtomic["v4.6"],
-    ...claudeAtomic["v4.5"],
-    ...claudeAtomic["v4.1"],
-    ...claudeAtomic["v4"],
-  ],
-  "v3.x": [...claudeAtomic["v3.7"], ...claudeAtomic["v3.5"], ...claudeAtomic["v3"]],
-} as const;
-
-export const claude = {
-  ...claudeAtomic,
-  ...claudeGroups,
-  latest: [...claudeAtomic["v4.6"]],
-  all: Object.values(claudeAtomic).flat(),
-} as const;

package/src/models/catalog.ts

@@ -1,13 +0,0 @@
-import type { ModelCatalog } from "./types";
-
-type ModelCatalogInput =
-  | ModelCatalog
-  | (() => ModelCatalog)
-  | ModelCatalog[]
-  | (() => ModelCatalog)[];
-
-export function defineModelCatalog(...inputs: ModelCatalogInput[]): ModelCatalog {
-  const catalogs = inputs.flat().map((input) => (typeof input === "function" ? input() : input));
-
-  return Object.assign({}, ...catalogs);
-}

package/src/models/cohere/index.ts

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

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

@@ -1,138 +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 { cohereDimensionsMiddleware, cohereReasoningMiddleware } from "./middleware";
-
-test("cohere middleware > matching patterns", () => {
-  const languageMatching = [
-    "cohere/command-a-reasoning",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const languageNonMatching = [
-    "cohere/command-a",
-    "cohere/command-r-plus",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of languageMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).toContain(cohereReasoningMiddleware);
-  }
-
-  for (const id of languageNonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "text", modelId: id });
-    expect(middleware).not.toContain(cohereReasoningMiddleware);
-  }
-
-  const embeddingMatching = [
-    "cohere/embed-v4.0",
-    "cohere/embed-english-v3.0",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  const embeddingNonMatching = [
-    "cohere/command-a",
-  ] satisfies (typeof CANONICAL_MODEL_IDS)[number][];
-
-  for (const id of embeddingMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).toContain(cohereDimensionsMiddleware);
-  }
-
-  for (const id of embeddingNonMatching) {
-    const middleware = modelMiddlewareMatcher.resolve({ kind: "embedding", modelId: id });
-    expect(middleware).not.toContain(cohereDimensionsMiddleware);
-  }
-});
-
-test("cohereReasoningMiddleware > should map effort to thinking budget", async () => {
-  const params = {
-    prompt: [],
-    maxOutputTokens: 2000,
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true, effort: "medium" },
-      },
-    },
-  };
-
-  const result = await cohereReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3(),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    maxOutputTokens: 2000,
-    providerOptions: {
-      cohere: {
-        thinking: {
-          type: "enabled",
-          tokenBudget: 1024,
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("cohereReasoningMiddleware > should disable reasoning when requested", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: false },
-      },
-    },
-  };
-
-  const result = await cohereReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3(),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    providerOptions: {
-      cohere: {
-        thinking: {
-          type: "disabled",
-        },
-      },
-      unknown: {},
-    },
-  });
-});
-
-test("cohereReasoningMiddleware > should default reasoning budget when enabled without effort", async () => {
-  const params = {
-    prompt: [],
-    maxOutputTokens: 4000,
-    providerOptions: {
-      unknown: {
-        reasoning: { enabled: true },
-      },
-    },
-  };
-
-  const result = await cohereReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3(),
-  });
-
-  expect(result).toEqual({
-    prompt: [],
-    maxOutputTokens: 4000,
-    providerOptions: {
-      cohere: {
-        thinking: {
-          type: "enabled",
-        },
-      },
-      unknown: {},
-    },
-  });
-});

package/src/models/cohere/middleware.ts

@@ -1,76 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-
-import type { ChatCompletionsReasoningConfig } from "../../endpoints/chat-completions/schema";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
-
-// Convert `dimensions` (OpenAI) to `outputDimension` (Cohere)
-export const cohereDimensionsMiddleware: EmbeddingModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    const unknown = params.providerOptions?.["unknown"];
-    if (!unknown) return params;
-
-    const modelId = model.modelId;
-    if (
-      modelId.includes("cohere/embed-english-light") ||
-      modelId.includes("cohere/embed-multilingual-light")
-    ) {
-      delete unknown["dimensions"];
-      return params;
-    }
-
-    const dimensions = unknown["dimensions"] as number;
-    if (!dimensions) return params;
-
-    (params.providerOptions!["cohere"] ??= {})["outputDimension"] = dimensions;
-    delete unknown["dimensions"];
-
-    return params;
-  },
-};
-
-const COHERE_MAX_OUTPUT_TOKENS = 32000;
-export const cohereReasoningMiddleware: 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!["cohere"] ??= {});
-
-    if (!reasoning.enabled) {
-      target["thinking"] = { type: "disabled" };
-    } else if (reasoning.max_tokens) {
-      target["thinking"] = { type: "enabled", tokenBudget: reasoning.max_tokens };
-    } else if (reasoning.effort) {
-      // FUTURE: warn that reasoning.max_tokens was computed
-      target["thinking"] = {
-        type: "enabled",
-        tokenBudget: calculateReasoningBudgetFromEffort(
-          reasoning.effort,
-          params.maxOutputTokens ?? COHERE_MAX_OUTPUT_TOKENS,
-          1024,
-        ),
-      };
-    } else {
-      target["thinking"] = { type: "enabled" };
-    }
-
-    delete unknown["reasoning"];
-
-    return params;
-  },
-};
-
-modelMiddlewareMatcher.useForModel("cohere/embed-*", { embedding: [cohereDimensionsMiddleware] });
-
-modelMiddlewareMatcher.useForModel("cohere/command-a-reasoning", {
-  language: [cohereReasoningMiddleware],
-});