@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/providers/bedrock/middleware.test.ts

@@ -1,303 +0,0 @@
-import { MockLanguageModelV3 } from "ai/test";
-import { expect, test } from "bun:test";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import {
-  bedrockClaudeReasoningMiddleware,
-  bedrockGptReasoningMiddleware,
-  bedrockPromptCachingMiddleware,
-} from "./middleware";
-
-test("bedrock middlewares > matching provider resolves GPT middleware", () => {
-  const middleware = modelMiddlewareMatcher.resolve({
-    kind: "text",
-    modelId: "openai/gpt-oss-20b",
-    providerId: "amazon-bedrock",
-  });
-
-  expect(middleware).toContain(bedrockGptReasoningMiddleware);
-});
-
-test("bedrock middlewares > matching provider resolves Claude middleware", () => {
-  const middleware = modelMiddlewareMatcher.resolve({
-    kind: "text",
-    modelId: "anthropic/claude-opus-4.6",
-    providerId: "amazon-bedrock",
-  });
-
-  expect(middleware).toContain(bedrockClaudeReasoningMiddleware);
-});
-
-test("bedrock middlewares > matching provider resolves prompt caching middleware for Claude", () => {
-  const middleware = modelMiddlewareMatcher.resolve({
-    kind: "text",
-    modelId: "anthropic/claude-opus-4.6",
-    providerId: "amazon-bedrock",
-  });
-
-  expect(middleware).toContain(bedrockPromptCachingMiddleware);
-});
-
-test("bedrock middlewares > matching provider resolves prompt caching middleware for Nova", () => {
-  const middleware = modelMiddlewareMatcher.resolve({
-    kind: "text",
-    modelId: "amazon/nova-2-lite",
-    providerId: "amazon-bedrock",
-  });
-
-  expect(middleware).toContain(bedrockPromptCachingMiddleware);
-});
-
-test("bedrockGptReasoningMiddleware > should map reasoningEffort into reasoningConfig", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      bedrock: {
-        reasoningEffort: "high",
-      },
-    },
-  };
-
-  const result = await bedrockGptReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-oss-20b" }),
-  });
-
-  expect(result.providerOptions?.bedrock).toEqual({
-    reasoningConfig: {
-      maxReasoningEffort: "high",
-    },
-  });
-});
-
-test("bedrockGptReasoningMiddleware > should skip non-gpt models", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      bedrock: {
-        reasoningEffort: "medium",
-      },
-    },
-  };
-
-  const result = await bedrockGptReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4.6" }),
-  });
-
-  expect(result.providerOptions?.bedrock).toEqual({
-    reasoningEffort: "medium",
-  });
-});
-
-test("bedrockClaudeReasoningMiddleware > should map thinking/effort into reasoningConfig", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      bedrock: {
-        thinking: {
-          type: "adaptive",
-          budgetTokens: 4096,
-        },
-        effort: "max",
-      },
-    },
-  };
-
-  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4-6" }),
-  });
-
-  expect(result.providerOptions?.bedrock).toEqual({
-    reasoningConfig: {
-      type: "adaptive",
-      budgetTokens: 4096,
-      maxReasoningEffort: "max",
-    },
-  });
-});
-
-test("bedrockClaudeReasoningMiddleware > should skip non-claude models", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      bedrock: {
-        thinking: {
-          type: "enabled",
-          budgetTokens: 4096,
-        },
-        effort: "high",
-      },
-    },
-  };
-
-  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-oss-20b" }),
-  });
-
-  expect(result.providerOptions?.bedrock).toEqual({
-    thinking: {
-      type: "enabled",
-      budgetTokens: 4096,
-    },
-    effort: "high",
-  });
-});
-
-test("bedrockClaudeReasoningMiddleware > should not set maxReasoningEffort for Claude 3.x", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      bedrock: {
-        thinking: {
-          type: "enabled",
-          budgetTokens: 4096,
-        },
-        effort: "high",
-      },
-    },
-  };
-
-  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "anthropic/claude-sonnet-3.7" }),
-  });
-
-  expect(result.providerOptions?.bedrock).toEqual({
-    reasoningConfig: {
-      type: "enabled",
-      budgetTokens: 4096,
-    },
-  });
-});
-
-test("bedrockClaudeReasoningMiddleware > should not set maxReasoningEffort for Claude 4.5", async () => {
-  const params = {
-    prompt: [],
-    providerOptions: {
-      bedrock: {
-        thinking: {
-          type: "enabled",
-          budgetTokens: 4096,
-        },
-        effort: "high",
-      },
-    },
-  };
-
-  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
-    type: "generate",
-    params,
-    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4.5" }),
-  });
-
-  expect(result.providerOptions?.bedrock).toEqual({
-    reasoningConfig: {
-      type: "enabled",
-      budgetTokens: 4096,
-    },
-  });
-});
-
-test("bedrockPromptCachingMiddleware > should map message and part cacheControl to cachePoint", async () => {
-  const params = {
-    prompt: [
-      {
-        role: "system",
-        content: [
-          {
-            type: "text",
-            text: "Policy",
-            providerOptions: {
-              bedrock: {
-                cacheControl: { type: "ephemeral", ttl: "1h" },
-              },
-            },
-          },
-        ],
-        providerOptions: {
-          bedrock: {
-            cacheControl: { type: "ephemeral", ttl: "1h" },
-          },
-        },
-      },
-    ],
-    providerOptions: {
-      bedrock: {},
-    },
-  };
-
-  const result = await bedrockPromptCachingMiddleware.transformParams!({
-    type: "generate",
-    params: params as any,
-    model: new MockLanguageModelV3({ modelId: "amazon/nova-2-lite" }),
-  });
-
-  expect((result.prompt[0] as any).providerOptions.bedrock.cachePoint).toEqual({
-    type: "default",
-  });
-  expect((result.prompt[0] as any).providerOptions.bedrock.cacheControl).toBeUndefined();
-  expect((result.prompt[0] as any).content[0].providerOptions.bedrock.cachePoint).toEqual({
-    type: "default",
-  });
-  expect((result.prompt[0] as any).content[0].providerOptions.bedrock.cacheControl).toBeUndefined();
-});
-
-test("bedrockPromptCachingMiddleware > should fallback from top-level cacheControl", async () => {
-  const params = {
-    prompt: [
-      {
-        role: "system",
-        content: "Reusable context",
-      },
-      {
-        role: "user",
-        content: "Question",
-      },
-    ],
-    providerOptions: {
-      bedrock: {
-        cacheControl: { type: "ephemeral", ttl: "1h" },
-      },
-    },
-  };
-
-  const result = await bedrockPromptCachingMiddleware.transformParams!({
-    type: "generate",
-    params: params as any,
-    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4.6" }),
-  });
-
-  expect((result.prompt[1] as any).providerOptions).toBeUndefined();
-  expect((result.providerOptions as any).bedrock.cacheControl).toBeUndefined();
-});
-
-test("bedrockPromptCachingMiddleware > should skip non-claude non-nova models", async () => {
-  const params = {
-    prompt: [{ role: "user", content: "Hello" }],
-    providerOptions: {
-      bedrock: {
-        cacheControl: { type: "ephemeral", ttl: "1h" },
-      },
-    },
-  };
-
-  const result = await bedrockPromptCachingMiddleware.transformParams!({
-    type: "generate",
-    params: params as any,
-    model: new MockLanguageModelV3({ modelId: "openai/gpt-oss-20b" }),
-  });
-
-  expect((result.providerOptions as any).bedrock.cacheControl).toEqual({
-    type: "ephemeral",
-    ttl: "1h",
-  });
-  expect((result.prompt[0] as any).providerOptions).toBeUndefined();
-});

package/src/providers/bedrock/middleware.ts

@@ -1,128 +0,0 @@
-import type { LanguageModelMiddleware } from "ai";
-
-import type { ChatCompletionsCacheControl } from "../../endpoints/chat-completions/schema";
-
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-
-const isClaude46 = (modelId: string) => modelId.includes("-4-6");
-
-export const bedrockGptReasoningMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    if (!model.modelId.includes("gpt")) return params;
-
-    const bedrock = params.providerOptions?.["bedrock"];
-    if (!bedrock || typeof bedrock !== "object") return params;
-
-    const effort = bedrock["reasoningEffort"];
-    if (effort === undefined) return params;
-
-    const target = (bedrock["reasoningConfig"] ??= {}) as Record<string, unknown>;
-    target["maxReasoningEffort"] = effort;
-
-    delete bedrock["reasoningEffort"];
-
-    return params;
-  },
-};
-
-export const bedrockClaudeReasoningMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    if (!model.modelId.includes("claude")) return params;
-
-    const bedrock = params.providerOptions?.["bedrock"];
-    if (!bedrock || typeof bedrock !== "object") return params;
-
-    const thinking = bedrock["thinking"];
-    const effort = bedrock["effort"];
-
-    if (!thinking && effort === undefined) return params;
-
-    const target = (bedrock["reasoningConfig"] ??= {}) as Record<string, unknown>;
-
-    if (thinking && typeof thinking === "object") {
-      const thinkingOptions = thinking as Record<string, unknown>;
-      if (thinkingOptions["type"] !== undefined) {
-        target["type"] = thinkingOptions["type"];
-      }
-      if (thinkingOptions["budgetTokens"] !== undefined) {
-        target["budgetTokens"] = thinkingOptions["budgetTokens"];
-      }
-    }
-
-    // FUTURE: bedrock currently does not support "effort" for other 4.x models
-    if (effort !== undefined && isClaude46(model.modelId)) {
-      target["maxReasoningEffort"] = effort;
-    }
-
-    delete bedrock["thinking"];
-    delete bedrock["effort"];
-
-    return params;
-  },
-};
-
-function toBedrockCachePoint(modelId: string, cacheControl?: ChatCompletionsCacheControl) {
-  const out: { type: "default"; ttl?: string } = { type: "default" };
-  // Nova currently only supports 5m
-  if (cacheControl?.ttl && !modelId.includes("nova")) {
-    out.ttl = cacheControl.ttl;
-  }
-  return out;
-}
-
-// https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
-export const bedrockPromptCachingMiddleware: LanguageModelMiddleware = {
-  specificationVersion: "v3",
-  // oxlint-disable-next-line require-await
-  transformParams: async ({ params, model }) => {
-    if (!model.modelId.includes("nova") && !model.modelId.includes("claude")) return params;
-
-    let hasExplicitCacheControl = false;
-    let lastCacheableBlock;
-
-    const processCacheControl = (providerOptions?: Record<string, any>) => {
-      if (!providerOptions) return;
-
-      const entryBedrock = providerOptions["bedrock"] as Record<string, unknown> | undefined;
-      const entryCacheControl = entryBedrock?.["cacheControl"] as ChatCompletionsCacheControl;
-      if (!entryBedrock || !entryCacheControl) return;
-
-      hasExplicitCacheControl = true;
-      entryBedrock["cachePoint"] = toBedrockCachePoint(model.modelId, entryCacheControl);
-      delete entryBedrock["cacheControl"];
-    };
-
-    for (const message of params.prompt) {
-      processCacheControl(message["providerOptions"]);
-
-      if (!Array.isArray(message["content"])) continue;
-      for (const part of message["content"]) {
-        processCacheControl(part["providerOptions"]);
-      }
-      lastCacheableBlock = message;
-    }
-
-    const bedrock = params.providerOptions?.["bedrock"];
-    const cacheControl = bedrock?.["cacheControl"] as ChatCompletionsCacheControl;
-    if (cacheControl && !hasExplicitCacheControl && lastCacheableBlock) {
-      ((lastCacheableBlock["providerOptions"] ??= {})["bedrock"] ??= {})["cachePoint"] =
-        toBedrockCachePoint(model.modelId, cacheControl);
-    }
-
-    delete bedrock?.["cacheControl"];
-
-    return params;
-  },
-};
-
-modelMiddlewareMatcher.useForProvider("amazon-bedrock", {
-  language: [
-    bedrockGptReasoningMiddleware,
-    bedrockClaudeReasoningMiddleware,
-    bedrockPromptCachingMiddleware,
-  ],
-});

package/src/providers/cohere/canonical.ts

@@ -1,26 +0,0 @@
-import { type CohereProvider } from "@ai-sdk/cohere";
-
-import type { CanonicalModelId, ModelId } from "../../models/types";
-
-import { withCanonicalIds } from "../registry";
-
-const MAPPING = {
-  "cohere/command-a": "command-a-03-2025",
-  "cohere/command-r7b": "command-r7b-12-2024",
-  "cohere/command-a-translate": "command-a-translate-08-2025",
-  "cohere/command-a-reasoning": "command-a-reasoning-08-2025",
-  "cohere/command-a-vision": "command-a-vision-07-2025",
-  "cohere/command-r": "command-r-08-2024",
-  "cohere/command-r-plus": "command-r-plus-08-2024",
-} as const satisfies Partial<Record<CanonicalModelId, string>>;
-
-export const withCanonicalIdsForCohere = (
-  provider: CohereProvider,
-  extraMapping?: Record<ModelId, string>,
-) =>
-  withCanonicalIds(provider, {
-    mapping: { ...MAPPING, ...extraMapping },
-    options: {
-      stripNamespace: true,
-    },
-  });

package/src/providers/cohere/index.ts

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

package/src/providers/groq/canonical.ts

@@ -1,21 +0,0 @@
-import { type GroqProvider } from "@ai-sdk/groq";
-
-import type { CanonicalModelId, ModelId } from "../../models/types";
-
-import { withCanonicalIds } from "../registry";
-
-const MAPPING = {
-  "meta/llama-3.1-8b": "llama-3.1-8b-instant",
-  "meta/llama-3.3-70b": "llama-3.3-70b-versatile",
-  "meta/llama-4-scout": "meta-llama/llama-4-scout-17b-16e-instruct",
-  "meta/llama-4-maverick": "meta-llama/llama-4-maverick-17b-128e-instruct",
-} as const satisfies Partial<Record<CanonicalModelId, string>>;
-
-export const withCanonicalIdsForGroq = (
-  provider: GroqProvider,
-  extraMapping?: Record<ModelId, string>,
-) =>
-  withCanonicalIds(provider, {
-    mapping: { ...MAPPING, ...extraMapping },
-    options: { stripNamespace: false },
-  });

package/src/providers/groq/index.ts

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

package/src/providers/openai/canonical.ts

@@ -1,16 +0,0 @@
-import { type OpenAIProvider } from "@ai-sdk/openai";
-
-import type { ModelId } from "../../models/types";
-
-import { withCanonicalIds } from "../registry";
-
-export const withCanonicalIdsForOpenAI = (
-  provider: OpenAIProvider,
-  extraMapping?: Record<ModelId, string>,
-) =>
-  withCanonicalIds(provider, {
-    mapping: extraMapping,
-    options: {
-      stripNamespace: true,
-    },
-  });

package/src/providers/openai/index.ts

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

package/src/providers/registry.test.ts

@@ -1,44 +0,0 @@
-import { expect, test } from "bun:test";
-import { createVoyage } from "voyage-ai-provider";
-
-import { voyage4Lite } from "../models/voyage/presets";
-import { withCanonicalIdsForVoyage } from "../providers/voyage/canonical";
-import { resolveProvider } from "./registry";
-
-test("Voyage 4 Lite ID transformation in gateway config", () => {
-  const config = {
-    providers: {
-      voyage: withCanonicalIdsForVoyage(
-        createVoyage({
-          apiKey: "test-key",
-        }),
-      ),
-    },
-    models: {
-      ...voyage4Lite({
-        providers: ["voyage"],
-      }),
-    },
-  };
-
-  const modelId = "voyage/voyage-4-lite";
-
-  // 1. Resolve the provider for embeddings
-  const provider = resolveProvider({
-    providers: config.providers,
-    models: config.models,
-    modelId,
-    operation: "embeddings",
-  });
-
-  // 2. Get the actual embedding model instance
-  const embeddingModel = provider.embeddingModel(modelId);
-
-  // 3. Verify the internal modelId is stripped of the 'voyage/' prefix
-  expect(embeddingModel.modelId).toBe("voyage-4-lite");
-
-  // 4. Check the providers registry directly
-  const registry = config.providers;
-  const directModel = registry["voyage"]!.embeddingModel(modelId);
-  expect(directModel.modelId).toBe("voyage-4-lite");
-});