@hebo-ai/gateway 0.9.0 → 0.9.2

package/dist/middleware/common.js

@@ -1,146 +0,0 @@
-function snakeToCamel(key) {
-    // oxlint-disable-next-line prefer-includes
-    if (key.indexOf("_") === -1)
-        return key;
-    let out = "";
-    for (let i = 0; i < key.length; i++) {
-        const c = key[i];
-        if (c === "_" && i + 1 < key.length) {
-            const next = key[i + 1];
-            if (next >= "a" && next <= "z") {
-                out += next.toUpperCase();
-                i++;
-                continue;
-            }
-        }
-        out += c;
-    }
-    return out;
-}
-function hasUppercase(s) {
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c >= "A" && c <= "Z")
-            return true;
-    }
-    return false;
-}
-function camelToSnake(key) {
-    if (!hasUppercase(key))
-        return key;
-    let out = "";
-    for (let i = 0; i < key.length; i++) {
-        const c = key[i];
-        out += c >= "A" && c <= "Z" ? "_" + c.toLowerCase() : c;
-    }
-    return out;
-}
-function remapDeep(value, mapKey) {
-    if (value === null || typeof value !== "object")
-        return value;
-    if (Array.isArray(value)) {
-        return value.map((v) => remapDeep(v, mapKey));
-    }
-    const out = {};
-    for (const key of Object.keys(value)) {
-        out[mapKey(key)] = remapDeep(value[key], mapKey);
-    }
-    return out;
-}
-function processOptions(options, providerName) {
-    const target = (options[providerName] = remapDeep(options[providerName] ?? {}, snakeToCamel));
-    for (const namespace in options) {
-        if (namespace === providerName)
-            continue;
-        Object.assign(target, remapDeep(options[namespace], snakeToCamel));
-        if (namespace === "unknown")
-            delete options[namespace];
-    }
-}
-function processMetadata(metadata) {
-    for (const namespace in metadata) {
-        metadata[namespace] = remapDeep(metadata[namespace], camelToSnake);
-    }
-}
-/**
- * Converts snake_case params in providerOptions to camelCase
- * and moves all of them into providerOptions[providerName].
- * Also snakizes values in providerMetadata for OpenAI compatibility.
- */
-export function forwardLanguageParams(providerName) {
-    return {
-        specificationVersion: "v3",
-        // oxlint-disable-next-line require-await
-        transformParams: async ({ params }) => {
-            if (params.providerOptions)
-                processOptions(params.providerOptions, providerName);
-            for (const message of params.prompt) {
-                if (message.providerOptions) {
-                    processOptions(message.providerOptions, providerName);
-                }
-                if (message.content && Array.isArray(message.content)) {
-                    for (const part of message.content) {
-                        if ("providerOptions" in part && part.providerOptions) {
-                            processOptions(part.providerOptions, providerName);
-                        }
-                    }
-                }
-            }
-            return params;
-        },
-        wrapGenerate: async ({ doGenerate }) => {
-            const result = await doGenerate();
-            if (result.providerMetadata)
-                processMetadata(result.providerMetadata);
-            result.content?.forEach((part) => {
-                if (part.providerMetadata)
-                    processMetadata(part.providerMetadata);
-            });
-            return result;
-        },
-        wrapStream: async ({ doStream }) => {
-            const result = await doStream();
-            result.stream = result.stream.pipeThrough(new TransformStream({
-                transform(part, controller) {
-                    if ("providerMetadata" in part && part.providerMetadata) {
-                        processMetadata(part.providerMetadata);
-                    }
-                    controller.enqueue(part);
-                },
-            }));
-            return result;
-        },
-    };
-}
-export function forwardEmbeddingParams(providerName) {
-    return {
-        specificationVersion: "v3",
-        // oxlint-disable-next-line require-await
-        transformParams: async ({ params }) => {
-            if (params.providerOptions)
-                processOptions(params.providerOptions, providerName);
-            return params;
-        },
-        wrapEmbed: async ({ doEmbed }) => {
-            const result = await doEmbed();
-            if (result.providerMetadata)
-                processMetadata(result.providerMetadata);
-            return result;
-        },
-    };
-}
-export function extractProviderNamespace(id) {
-    if (id === "amazon-bedrock")
-        return "bedrock";
-    const [first, second] = id.split(".");
-    // FUTURE: map vertex to google once AI SDK support per-message level provider options
-    if (first === "vertex" || second === "vertex")
-        return "vertex";
-    return first;
-}
-export function forwardParamsMiddleware(provider) {
-    return forwardLanguageParams(extractProviderNamespace(provider));
-}
-export function forwardParamsEmbeddingMiddleware(provider) {
-    return forwardEmbeddingParams(extractProviderNamespace(provider));
-}

package/dist/middleware/debug.d.ts

@@ -1,3 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-export declare const debugFinalParamsMiddleware: LanguageModelMiddleware;
-export declare const debugEmbeddingFinalParamsMiddleware: EmbeddingModelMiddleware;

package/dist/middleware/debug.js

@@ -1,27 +0,0 @@
-import { logger } from "../logger";
-export const debugFinalParamsMiddleware = {
-    specificationVersion: "v3",
-    // oxlint-disable-next-line require-await
-    transformParams: async ({ params, model }) => {
-        logger.trace({
-            kind: "text",
-            modelId: model.modelId,
-            providerId: model.provider,
-            params,
-        }, "[middleware] final params");
-        return params;
-    },
-};
-export const debugEmbeddingFinalParamsMiddleware = {
-    specificationVersion: "v3",
-    // oxlint-disable-next-line require-await
-    transformParams: async ({ params, model }) => {
-        logger.trace({
-            kind: "embedding",
-            modelId: model.modelId,
-            providerId: model.provider,
-            params,
-        }, "[middleware] final params");
-        return params;
-    },
-};

package/dist/middleware/matcher.d.ts

@@ -1,28 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-import type { ModelId } from "../models/types";
-import type { ProviderId } from "../providers/types";
-type MiddlewareEntries = {
-    language?: LanguageModelMiddleware[];
-    embedding?: EmbeddingModelMiddleware[];
-};
-type ModelMiddleware = LanguageModelMiddleware | EmbeddingModelMiddleware;
-declare class ModelMiddlewareMatcher {
-    private model;
-    private provider;
-    private static readonly MAX_CACHE;
-    private cache;
-    useForModel(patterns: ModelId | readonly ModelId[], entry: MiddlewareEntries): void;
-    useForProvider(patterns: ProviderId | readonly ProviderId[], entry: MiddlewareEntries): void;
-    for(modelId: ModelId, providerId: ProviderId): LanguageModelMiddleware[];
-    forEmbedding(modelId: ModelId, providerId: ProviderId): EmbeddingModelMiddleware[];
-    resolve(options: {
-        kind: "text" | "embedding";
-        modelId?: ModelId;
-        providerId?: ProviderId;
-        forward?: ModelMiddleware | (() => ModelMiddleware);
-        debug?: ModelMiddleware;
-    }): ModelMiddleware[];
-    private collect;
-}
-export declare const modelMiddlewareMatcher: ModelMiddlewareMatcher;
-export type { ModelMiddlewareMatcher };

package/dist/middleware/matcher.js

@@ -1,118 +0,0 @@
-import { logger } from "../logger";
-import { addSpanEvent } from "../telemetry/span";
-import { forwardParamsEmbeddingMiddleware, forwardParamsMiddleware } from "./common";
-import { debugEmbeddingFinalParamsMiddleware, debugFinalParamsMiddleware } from "./debug";
-class SimpleMatcher {
-    rules = [];
-    use(pattern, entry) {
-        const stored = {
-            language: entry.language ? [...entry.language] : undefined,
-            embedding: entry.embedding ? [...entry.embedding] : undefined,
-        };
-        this.rules.push({ pattern, test: compilePattern(pattern), stored });
-    }
-    match(key) {
-        const out = [];
-        const matched = [];
-        for (const r of this.rules) {
-            if (!r.test(key))
-                continue;
-            out.push(r.stored);
-            matched.push(r.pattern);
-        }
-        const matchedSummary = matched.length > 0 ? matched.join(",") : "none";
-        logger.debug(`[middleware] matched ${key} to [${matchedSummary}]`);
-        return out;
-    }
-}
-class ModelMiddlewareMatcher {
-    model = new SimpleMatcher();
-    provider = new SimpleMatcher();
-    static MAX_CACHE = 500;
-    cache = new Map();
-    useForModel(patterns, entry) {
-        this.cache.clear();
-        for (const pattern of toArray(patterns)) {
-            this.model.use(pattern, entry);
-        }
-    }
-    useForProvider(patterns, entry) {
-        this.cache.clear();
-        for (const pattern of toArray(patterns)) {
-            this.provider.use(pattern, entry);
-        }
-    }
-    for(modelId, providerId) {
-        return this.resolve({
-            kind: "text",
-            modelId,
-            providerId,
-            forward: () => forwardParamsMiddleware(providerId),
-            debug: debugFinalParamsMiddleware,
-        });
-    }
-    forEmbedding(modelId, providerId) {
-        return this.resolve({
-            kind: "embedding",
-            modelId,
-            providerId,
-            forward: () => forwardParamsEmbeddingMiddleware(providerId),
-            debug: debugEmbeddingFinalParamsMiddleware,
-        });
-    }
-    resolve(options) {
-        const { kind, modelId, providerId, forward, debug } = options;
-        const key = `${kind}-${modelId}:${providerId}`;
-        const cached = this.cache.get(key);
-        if (cached) {
-            logger.debug(`[middleware] cache hit for ${modelId}:${providerId}`);
-            return cached;
-        }
-        const out = [];
-        if (modelId) {
-            out.push(...this.collect(this.model.match(modelId), kind));
-        }
-        if (forward) {
-            out.push(typeof forward === "function" ? forward() : forward);
-        }
-        if (providerId) {
-            out.push(...this.collect(this.provider.match(providerId), kind));
-        }
-        if (debug) {
-            out.push(debug);
-        }
-        if (this.cache.size >= ModelMiddlewareMatcher.MAX_CACHE) {
-            let n = Math.ceil(ModelMiddlewareMatcher.MAX_CACHE * 0.2);
-            for (const cacheKey of this.cache.keys()) {
-                this.cache.delete(cacheKey);
-                if (--n === 0)
-                    break;
-            }
-            logger.warn(`[middleware] cache eviction`);
-            addSpanEvent("hebo.middleware.cache.evicted");
-        }
-        this.cache.set(key, out);
-        return out;
-    }
-    collect(entries, kind) {
-        const out = [];
-        for (const s of entries) {
-            if (kind === "text")
-                out.push(...(s.language ?? []));
-            else
-                out.push(...(s.embedding ?? []));
-        }
-        return out;
-    }
-}
-export const modelMiddlewareMatcher = new ModelMiddlewareMatcher();
-const toArray = (v) => (Array.isArray(v) ? v : [v]);
-function compilePattern(pattern) {
-    if (!pattern.includes("*"))
-        return (key) => key === pattern;
-    const re = new RegExp(`^${pattern
-        .split("*")
-        .map((p) => p.replaceAll(/[-\\^$+?.()|[\]{}]/g, "\\$&"))
-        .join(".*")}$`);
-    return (key) => re.test(key);
-}

package/dist/middleware/utils.d.ts

@@ -1,2 +0,0 @@
-import type { ChatCompletionsReasoningEffort } from "../endpoints/chat-completions/schema";
-export declare function calculateReasoningBudgetFromEffort(effort: ChatCompletionsReasoningEffort, maxTokens: number, minTokens?: number): number;

package/dist/middleware/utils.js

@@ -1,24 +0,0 @@
-export function calculateReasoningBudgetFromEffort(effort, maxTokens, minTokens = 1024) {
-    let percentage = 0;
-    switch (effort) {
-        case "none":
-            percentage = 0;
-            break;
-        case "minimal":
-            percentage = 0.1;
-            break;
-        case "low":
-            percentage = 0.2;
-            break;
-        case "medium":
-            percentage = 0.5;
-            break;
-        case "high":
-            percentage = 0.8;
-            break;
-        case "xhigh":
-            percentage = 0.95;
-            break;
-    }
-    return Math.max(minTokens, Math.floor(maxTokens * percentage));
-}

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

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

package/dist/models/amazon/index.js

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

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

@@ -1,3 +0,0 @@
-import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
-export declare const novaDimensionsMiddleware: EmbeddingModelMiddleware;
-export declare const novaReasoningMiddleware: LanguageModelMiddleware;

package/dist/models/amazon/middleware.js

@@ -1,68 +0,0 @@
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-// Convert `dimensions` (OpenAI) to `embeddingDimension` (Nova)
-export const novaDimensionsMiddleware = {
-    specificationVersion: "v3",
-    // oxlint-disable-next-line require-await
-    transformParams: async ({ params }) => {
-        const unknown = params.providerOptions?.["unknown"];
-        if (!unknown)
-            return params;
-        const dimensions = unknown["dimensions"];
-        if (!dimensions)
-            return params;
-        const target = (params.providerOptions["nova"] ??= {});
-        // @ts-expect-error AI SDK does the value checking for us
-        target.embeddingDimension = dimensions;
-        delete unknown["dimensions"];
-        return params;
-    },
-};
-function mapNovaEffort(effort) {
-    switch (effort) {
-        case "none":
-            return;
-        case "minimal":
-        case "low":
-            return "low";
-        case "medium":
-            return "medium";
-        case "high":
-        case "xhigh":
-            return "high";
-    }
-}
-export const novaReasoningMiddleware = {
-    specificationVersion: "v3",
-    // oxlint-disable-next-line require-await
-    transformParams: async ({ params }) => {
-        const unknown = params.providerOptions?.["unknown"];
-        if (!unknown)
-            return params;
-        const reasoning = unknown["reasoning"];
-        if (!reasoning)
-            return params;
-        const target = (params.providerOptions["amazon"] ??= {});
-        if (!reasoning.enabled) {
-            target.reasoningConfig = { type: "disabled" };
-        }
-        else if (reasoning.effort) {
-            // FUTURE: warn if mapNovaEffort modified the effort
-            target.reasoningConfig = {
-                type: "enabled",
-                maxReasoningEffort: mapNovaEffort(reasoning.effort),
-            };
-        }
-        else {
-            // FUTURE: warn if reasoning.max_tokens (unsupported) was ignored
-            target.reasoningConfig = { type: "enabled" };
-        }
-        delete unknown["reasoning"];
-        return params;
-    },
-};
-modelMiddlewareMatcher.useForModel("amazon/nova-*embeddings*", {
-    embedding: [novaDimensionsMiddleware],
-});
-modelMiddlewareMatcher.useForModel("amazon/nova-2-*", {
-    language: [novaReasoningMiddleware],
-});