@hebo-ai/gateway 0.1.2 → 0.2.0

package/dist/endpoints/models/schema.d.ts

@@ -1,36 +1,42 @@
-import * as z from "zod/mini";
-export declare const ModelSchema: z.ZodMiniObject<{
-    id: z.ZodMiniString<string>;
-    object: z.ZodMiniLiteral<"model">;
-    created: z.ZodMiniNumber<number>;
-    owned_by: z.ZodMiniString<string>;
-    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    architecture: z.ZodMiniOptional<z.ZodMiniObject<{
-        modality: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        input_modalities: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniString<string>>>;
-        output_modalities: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniString<string>>>;
+import * as z from "zod";
+export declare const ModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"model">;
+    created: z.ZodInt;
+    owned_by: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    knowledge: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodInt>;
+    architecture: z.ZodOptional<z.ZodObject<{
+        modality: z.ZodOptional<z.ZodString>;
+        input_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        output_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>;
-    endpoints: z.ZodMiniArray<z.ZodMiniObject<{
-        tag: z.ZodMiniString<string>;
-    }, z.core.$strip>>;
-}, z.core.$catchall<z.ZodMiniUnknown>>;
+    endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tag: z.ZodString;
+    }, z.core.$strip>>>;
+    capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$loose>;
 export type Model = z.infer<typeof ModelSchema>;
-export declare const ModelListSchema: z.ZodMiniObject<{
-    object: z.ZodMiniLiteral<"list">;
-    data: z.ZodMiniArray<z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        object: z.ZodMiniLiteral<"model">;
-        created: z.ZodMiniNumber<number>;
-        owned_by: z.ZodMiniString<string>;
-        description: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        architecture: z.ZodMiniOptional<z.ZodMiniObject<{
-            modality: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            input_modalities: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniString<string>>>;
-            output_modalities: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniString<string>>>;
-        }, z.core.$strip>>;
-        endpoints: z.ZodMiniArray<z.ZodMiniObject<{
-            tag: z.ZodMiniString<string>;
+export declare const ModelListSchema: z.ZodObject<{
+    object: z.ZodLiteral<"list">;
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"model">;
+        created: z.ZodInt;
+        owned_by: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        knowledge: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodInt>;
+        architecture: z.ZodOptional<z.ZodObject<{
+            modality: z.ZodOptional<z.ZodString>;
+            input_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            output_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         }, z.core.$strip>>;
-    }, z.core.$catchall<z.ZodMiniUnknown>>>;
+        endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tag: z.ZodString;
+        }, z.core.$strip>>>;
+        capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$loose>>;
 }, z.core.$strip>;
 export type ModelList = z.infer<typeof ModelListSchema>;

package/dist/endpoints/models/schema.js

@@ -1,19 +1,30 @@
-import * as z from "zod/mini";
-export const ModelSchema = z.catchall(z.object({
+import * as z from "zod";
+export const ModelSchema = z.looseObject({
+    // Core
     id: z.string(),
     object: z.literal("model"),
-    created: z.number(),
+    created: z.int().nonnegative(),
     owned_by: z.string(),
-    description: z.optional(z.string()),
-    architecture: z.optional(z.object({
-        modality: z.optional(z.string()),
-        input_modalities: z.readonly(z.array(z.string())),
-        output_modalities: z.readonly(z.array(z.string())),
-    })),
-    endpoints: z.array(z.object({
+    // Extensions
+    name: z.string().optional().meta({ extension: true }),
+    knowledge: z.string().optional().meta({ extension: true }),
+    context: z.int().nonnegative().optional().meta({ extension: true }),
+    architecture: z
+        .object({
+        modality: z.string().optional(),
+        input_modalities: z.array(z.string()).readonly().optional(),
+        output_modalities: z.array(z.string()).readonly().optional(),
+    })
+        .optional()
+        .meta({ extension: true }),
+    endpoints: z
+        .array(z.object({
         tag: z.string(),
-    })),
-}), z.unknown());
+    }))
+        .optional()
+        .meta({ extension: true }),
+    capabilities: z.array(z.string()).readonly().optional().meta({ extension: true }),
+});
 export const ModelListSchema = z.object({
     object: z.literal("list"),
     data: z.array(ModelSchema),

package/dist/gateway.d.ts

@@ -1,10 +1,9 @@
-import type { Endpoint, GatewayConfig, GatewayConfigBase, GatewayConfigRegistry, HeboGateway } from "./types";
-declare const buildRoutes: (config: GatewayConfig) => {
-    readonly "/chat/completions": Endpoint;
-    readonly "/embeddings": Endpoint;
-    readonly "/models": Endpoint;
+import type { Endpoint, GatewayConfig } from "./types";
+export declare function gateway(config: GatewayConfig): {
+    handler: (req: Request, state?: Record<string, unknown>) => Promise<Response>;
+    routes: {
+        readonly "/chat/completions": Endpoint;
+        readonly "/embeddings": Endpoint;
+        readonly "/models": Endpoint;
+    };
 };
-type GatewayRoutes = ReturnType<typeof buildRoutes>;
-export declare function gateway(config: GatewayConfigBase): HeboGateway<GatewayRoutes>;
-export declare function gateway(config: GatewayConfigRegistry): HeboGateway<GatewayRoutes>;
-export {};

package/dist/gateway.js

@@ -1,25 +1,22 @@
-import { parseConfig } from "./config";
 import { chatCompletions } from "./endpoints/chat-completions/handler";
 import { embeddings } from "./endpoints/embeddings/handler";
 import { models } from "./endpoints/models/handler";
-const buildRoutes = (config) => ({
-    ["/chat/completions"]: chatCompletions(config),
-    ["/embeddings"]: embeddings(config),
-    ["/models"]: models(config),
-});
 export function gateway(config) {
-    const parsedConfig = parseConfig(config);
     const basePath = (config.basePath ?? "").replace(/\/+$/, "");
-    const routes = buildRoutes(parsedConfig);
+    const routes = {
+        ["/chat/completions"]: chatCompletions(config),
+        ["/embeddings"]: embeddings(config),
+        ["/models"]: models(config),
+    };
     const routeEntries = Object.entries(routes);
-    const handler = (req) => {
+    const handler = (req, state) => {
         let pathname = new URL(req.url).pathname;
         if (basePath && pathname.startsWith(basePath)) {
             pathname = pathname.slice(basePath.length);
         }
         for (const [route, endpoint] of routeEntries) {
             if (pathname === route || pathname.startsWith(route + "/")) {
-                return endpoint.handler(req);
+                return endpoint.handler(req, state);
             }
         }
         return Promise.resolve(new Response("Not Found", { status: 404 }));

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./gateway";
 export type * from "./types";
+export * from "./middleware/common";
+export * from "./middleware/matcher";
 export * from "./endpoints/chat-completions";
 export * from "./endpoints/embeddings";
 export * from "./endpoints/models";

package/dist/index.js

@@ -1,4 +1,6 @@
 export * from "./gateway";
+export * from "./middleware/common";
+export * from "./middleware/matcher";
 export * from "./endpoints/chat-completions";
 export * from "./endpoints/embeddings";
 export * from "./endpoints/models";

package/dist/lifecycle.d.ts

@@ -0,0 +1,2 @@
+import type { GatewayConfig, GatewayContext } from "./types";
+export declare const withLifecycle: (run: (ctx: GatewayContext) => Promise<Response>, config: GatewayConfig) => (request: Request, state?: Record<string, unknown>) => Promise<Response>;

package/dist/{utils/hooks.js → lifecycle.js}

@@ -1,4 +1,5 @@
-import { createErrorResponse } from "./errors";
+import { parseConfig } from "./config";
+import { createErrorResponse } from "./utils/errors";
 const maybeApplyRequestPatch = (request, patch) => {
     if (!patch.headers && patch.body === undefined)
         return request;
@@ -15,27 +16,34 @@ const maybeApplyRequestPatch = (request, patch) => {
         init.body = patch.body;
     return new Request(request, init);
 };
-export const withHooks = (hooks, run) => {
-    const handler = async (request) => {
+export const withLifecycle = (run, config) => {
+    const parsedConfig = parseConfig(config);
+    const handler = async (request, state) => {
+        const context = {
+            request,
+            state: state ?? {},
+            providers: parsedConfig.providers,
+            models: parsedConfig.models,
+        };
         let beforeResult;
         try {
-            beforeResult = await hooks?.before?.({ request });
+            beforeResult = await parsedConfig.hooks?.before?.(context);
         }
         catch (error) {
             return createErrorResponse("INTERNAL_SERVER_ERROR", error, 500);
         }
         if (beforeResult instanceof Response)
             return beforeResult;
-        const nextRequest = beforeResult ? maybeApplyRequestPatch(request, beforeResult) : request;
-        const response = await run(nextRequest);
+        context.request = beforeResult ? maybeApplyRequestPatch(request, beforeResult) : request;
+        context.response = await run(context);
         let after;
         try {
-            after = await hooks?.after?.({ response });
+            after = await parsedConfig.hooks?.after?.(context);
         }
         catch (error) {
             return createErrorResponse("INTERNAL_SERVER_ERROR", error, 500);
         }
-        return after ?? response;
+        return after ?? context.response;
     };
     return handler;
 };

package/dist/middleware/common.d.ts

@@ -0,0 +1,4 @@
+import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
+import type { ProviderId } from "../providers/types";
+export declare function forwardParamsMiddleware(providerName: ProviderId): LanguageModelMiddleware;
+export declare function forwardParamsEmbeddingMiddleware(providerName: ProviderId): EmbeddingModelMiddleware;

package/dist/middleware/common.js

@@ -0,0 +1,44 @@
+function snakeToCamel(key) {
+    return key.replaceAll(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelizeKeysDeep(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((v) => camelizeKeysDeep(v));
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (v === undefined || v === null)
+            continue;
+        out[snakeToCamel(k)] = camelizeKeysDeep(v);
+    }
+    return out;
+}
+function forwardParamsForMiddleware(_kind, providerName) {
+    return {
+        specificationVersion: "v3",
+        // eslint-disable-next-line require-await
+        transformParams: async (options) => {
+            const { params } = options;
+            const providerOptions = params.providerOptions;
+            if (!providerOptions)
+                return params;
+            const target = (providerOptions[providerName] ??= {});
+            for (const key in providerOptions) {
+                if (key === providerName)
+                    continue;
+                Object.assign(target, camelizeKeysDeep(providerOptions[key]));
+                if (key === "unknown")
+                    delete providerOptions[key];
+            }
+            return params;
+        },
+    };
+}
+export function forwardParamsMiddleware(providerName) {
+    return forwardParamsForMiddleware("language", providerName);
+}
+export function forwardParamsEmbeddingMiddleware(providerName) {
+    return forwardParamsForMiddleware("embedding", providerName);
+}

package/dist/middleware/matcher.d.ts

@@ -0,0 +1,18 @@
+import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
+import type { ModelId } from "../models/types";
+import type { ProviderId } from "../providers/types";
+type MiddlewareEntry = {
+    language?: LanguageModelMiddleware | LanguageModelMiddleware[];
+    embedding?: EmbeddingModelMiddleware | EmbeddingModelMiddleware[];
+};
+declare class ModelMiddlewareMatcher {
+    private model;
+    private provider;
+    useForModel(patterns: ModelId | readonly ModelId[], entry: MiddlewareEntry): void;
+    useForProvider(patterns: ProviderId | readonly ProviderId[], entry: MiddlewareEntry): void;
+    for(modelId: ModelId, providerId: ProviderId): LanguageModelMiddleware[];
+    forEmbedding(modelId: ModelId, providerId: ProviderId): EmbeddingModelMiddleware[];
+}
+export declare const modelMiddlewareMatcher: ModelMiddlewareMatcher;
+export type { ModelMiddlewareMatcher };
+export declare function extractProviderNamespace(id: string): string;

package/dist/middleware/matcher.js

@@ -0,0 +1,83 @@
+import { forwardParamsMiddleware, forwardParamsEmbeddingMiddleware } from "./common";
+class SimpleMatcher {
+    rules = [];
+    cache = new Map();
+    static MAX_CACHE = 500;
+    use(pattern, entry) {
+        this.cache.clear();
+        const stored = { language: [], embedding: [] };
+        if (entry.language)
+            stored.language.push(...toArray(entry.language));
+        if (entry.embedding)
+            stored.embedding.push(...toArray(entry.embedding));
+        this.rules.push({ pattern, test: compilePattern(pattern), stored });
+    }
+    match(key) {
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const out = [];
+        for (const r of this.rules)
+            if (r.test(key))
+                out.push(r.stored);
+        if (this.cache.size >= SimpleMatcher.MAX_CACHE) {
+            let n = Math.ceil(SimpleMatcher.MAX_CACHE * 0.2);
+            for (const key of this.cache.keys()) {
+                this.cache.delete(key);
+                if (--n === 0)
+                    break;
+            }
+        }
+        this.cache.set(key, out);
+        return out;
+    }
+}
+class ModelMiddlewareMatcher {
+    model = new SimpleMatcher();
+    provider = new SimpleMatcher();
+    useForModel(patterns, entry) {
+        for (const pattern of toArray(patterns)) {
+            this.model.use(pattern, entry);
+        }
+    }
+    useForProvider(patterns, entry) {
+        for (const pattern of toArray(patterns)) {
+            this.provider.use(pattern, entry);
+        }
+    }
+    for(modelId, providerId) {
+        const out = [];
+        for (const s of this.model.match(modelId))
+            out.push(...s.language);
+        out.push(forwardParamsMiddleware(extractProviderNamespace(providerId)));
+        for (const s of this.provider.match(providerId))
+            out.push(...s.language);
+        return out;
+    }
+    forEmbedding(modelId, providerId) {
+        const out = [];
+        for (const s of this.model.match(modelId))
+            out.push(...s.embedding);
+        out.push(forwardParamsEmbeddingMiddleware(extractProviderNamespace(providerId)));
+        for (const s of this.provider.match(providerId))
+            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);
+}
+export function extractProviderNamespace(id) {
+    const firstDot = id.indexOf(".");
+    const head = firstDot === -1 ? id : id.slice(0, firstDot);
+    const dash = head.indexOf("-");
+    return dash === -1 ? head : head.slice(dash + 1);
+}

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

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

package/dist/models/amazon/index.js

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

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

@@ -0,0 +1,2 @@
+import type { EmbeddingModelMiddleware } from "ai";
+export declare const novaEmbeddingModelMiddleware: EmbeddingModelMiddleware;

package/dist/models/amazon/middleware.js

@@ -0,0 +1,20 @@
+import { modelMiddlewareMatcher } from "../../middleware/matcher";
+// Convert `dimensions` (OpenAI) to `embeddingDimension` (Nova)
+export const novaEmbeddingModelMiddleware = {
+    specificationVersion: "v3",
+    // eslint-disable-next-line require-await
+    transformParams: async ({ params }) => {
+        const unknown = params.providerOptions?.["unknown"];
+        if (!unknown)
+            return params;
+        let dimensions = unknown["dimensions"];
+        if (!dimensions)
+            dimensions = 1024;
+        (params.providerOptions["nova"] ??= {})["embeddingDimension"] = dimensions;
+        delete unknown["dimensions"];
+        return params;
+    },
+};
+modelMiddlewareMatcher.useForModel("amazon/nova-*embeddings*", {
+    embedding: novaEmbeddingModelMiddleware,
+});