@hebo-ai/gateway 0.5.2 → 0.6.0-rc0

package/dist/models/amazon/presets.js

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

package/dist/models/anthropic/index.d.ts

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

package/dist/models/anthropic/index.js

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

package/dist/models/anthropic/middleware.d.ts

@@ -1,4 +0,0 @@
-import type { LanguageModelMiddleware } from "ai";
-import type { ChatCompletionsReasoningEffort } from "../../endpoints/chat-completions/schema";
-export declare function mapClaudeReasoningEffort(effort: ChatCompletionsReasoningEffort, modelId: string): "low" | "high" | "medium" | "max";
-export declare const claudeReasoningMiddleware: LanguageModelMiddleware;

package/dist/models/anthropic/middleware.js

@@ -1,111 +0,0 @@
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
-const isClaude = (family, version) => {
-    const dashed = version.replace(".", "-");
-    return (modelId) => modelId.includes(`claude-${family}-${version}`) ||
-        modelId.includes(`claude-${family}-${dashed}`);
-};
-const isClaude4 = (modelId) => 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, modelId) {
-    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) {
-    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 = {
-    specificationVersion: "v3",
-    // eslint-disable-next-line require-await
-    transformParams: async ({ params, model }) => {
-        const unknown = params.providerOptions?.["unknown"];
-        if (!unknown)
-            return params;
-        const reasoning = unknown["reasoning"];
-        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;
-    },
-};
-modelMiddlewareMatcher.useForModel(["anthropic/claude-*3*7*", "anthropic/claude-*4*"], {
-    language: [claudeReasoningMiddleware],
-});