@hebo-ai/gateway 0.9.2 → 0.9.4

package/dist/utils/headers.js

@@ -0,0 +1,22 @@
+export const REQUEST_ID_HEADER = "x-request-id";
+export const resolveRequestId = (source) => {
+    if (!source)
+        return undefined;
+    if (source instanceof Request) {
+        return source.headers.get(REQUEST_ID_HEADER) ?? undefined;
+    }
+    const headers = source.headers;
+    if (!headers)
+        return undefined;
+    if (headers instanceof Headers) {
+        return headers.get(REQUEST_ID_HEADER) ?? undefined;
+    }
+    if (Array.isArray(headers)) {
+        for (const [key, value] of headers) {
+            if (key.toLowerCase() === REQUEST_ID_HEADER)
+                return value;
+        }
+        return undefined;
+    }
+    return headers[REQUEST_ID_HEADER];
+};

package/dist/utils/preset.d.ts

@@ -0,0 +1,10 @@
+export type DeepPartial<T> = T extends (...args: unknown[]) => unknown ? T : T extends readonly (infer U)[] ? readonly DeepPartial<U>[] : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * Deep merge where overrides win.
+ * Arrays are replaced.
+ */
+export declare function deepMerge<A extends object, B extends object>(base: A, override?: B): A & B;
+export type Preset<Id extends string, T extends Record<string, unknown>, Base extends DeepPartial<T>> = <O extends DeepPartial<T>>(override?: O) => Record<Id, Base & O>;
+export declare function presetFor<Ids extends string, T extends Record<string, unknown>>(): <const Id extends Ids, const Base extends DeepPartial<T>>(id: Id, base: Base) => Preset<Id, T, Base>;

package/dist/utils/preset.js

@@ -0,0 +1,41 @@
+function isPlainObject(v) {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Deep merge where overrides win.
+ * Arrays are replaced.
+ */
+export function deepMerge(base, override) {
+    if (override === null || override === undefined)
+        return base;
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return override;
+    }
+    const out = { ...base };
+    for (const [key, ov] of Object.entries(override)) {
+        if (ov === undefined)
+            continue;
+        const bv = out[key];
+        if (Array.isArray(ov)) {
+            out[key] = ov;
+            continue;
+        }
+        if (isPlainObject(bv) && isPlainObject(ov)) {
+            out[key] = deepMerge(bv, ov);
+            continue;
+        }
+        out[key] = ov;
+    }
+    return out;
+}
+export function presetFor() {
+    return function preset(id, base) {
+        return (override) => {
+            const merged = deepMerge(base, override ?? {});
+            return { [id]: merged };
+        };
+    };
+}

package/dist/utils/request.d.ts

@@ -0,0 +1,2 @@
+export declare const resolveOrCreateRequestId: (request: Request) => string;
+export declare const prepareForwardHeaders: (request: Request) => Record<string, string>;

package/dist/utils/request.js

@@ -0,0 +1,43 @@
+import pkg from "../../package.json" with { type: "json" };
+import { resolveRequestId } from "./headers";
+const GATEWAY_VERSION = pkg.version;
+const FORWARD_HEADER_ALLOWLIST = [
+    // OpenAI + OpenAI-compatible providers (Azure, Groq, Together, Fireworks, etc.)
+    "openai-beta",
+    "openai-organization",
+    "openai-project",
+    // OpenRouter
+    "x-openrouter-categories",
+    "x-openrouter-title",
+    "x-title",
+    // Anthropic
+    "anthropic-beta",
+    // AWS Bedrock
+    "x-amzn-bedrock-guardrailidentifier",
+    "x-amzn-bedrock-guardrailversion",
+    "x-amzn-bedrock-performanceconfig-latency",
+    "x-amzn-bedrock-trace",
+    // Cohere
+    "x-client-name",
+    // Vertex provisioned throughput / endpoint routing
+    "x-vertex-ai-endpoint-id",
+    "x-vertex-ai-llm-request-type",
+    "x-vertex-ai-llm-shared-request-type",
+];
+const createRequestId = () => "req_" + crypto.getRandomValues(new Uint32Array(2)).reduce((s, n) => s + n.toString(36), "");
+export const resolveOrCreateRequestId = (request) => resolveRequestId(request) ?? createRequestId();
+export const prepareForwardHeaders = (request) => {
+    const userAgent = request.headers.get("user-agent");
+    const appendedUserAgent = userAgent
+        ? `${userAgent} @hebo-ai/gateway/${GATEWAY_VERSION}`
+        : `@hebo-ai/gateway/${GATEWAY_VERSION}`;
+    const headers = {
+        "user-agent": appendedUserAgent,
+    };
+    for (const key of FORWARD_HEADER_ALLOWLIST) {
+        const value = request.headers.get(key);
+        if (value !== null)
+            headers[key] = value;
+    }
+    return headers;
+};

package/dist/utils/response.d.ts

@@ -0,0 +1,6 @@
+import type { SseFrame } from "./stream";
+export declare const prepareResponseInit: (requestId: string) => ResponseInit;
+export declare const mergeResponseInit: (defaultHeaders: HeadersInit, responseInit?: ResponseInit) => ResponseInit;
+export declare const toResponse: (result: ReadableStream<SseFrame> | Uint8Array<ArrayBuffer> | object | string, responseInit?: ResponseInit, streamOptions?: {
+    onDone?: (status: number, reason?: unknown) => void;
+}) => Response;

package/dist/utils/response.js

@@ -0,0 +1,55 @@
+import { REQUEST_ID_HEADER } from "./headers";
+import { toSseStream } from "./stream";
+const TEXT_ENCODER = new TextEncoder();
+export const prepareResponseInit = (requestId) => ({
+    headers: { [REQUEST_ID_HEADER]: requestId },
+});
+export const mergeResponseInit = (defaultHeaders, responseInit) => {
+    const headers = new Headers(defaultHeaders);
+    const override = responseInit?.headers;
+    if (override) {
+        new Headers(override).forEach((value, key) => {
+            headers.set(key, value);
+        });
+    }
+    if (!responseInit)
+        return { headers };
+    return {
+        status: responseInit.status,
+        statusText: responseInit.statusText,
+        headers,
+    };
+};
+export const toResponse = (result, responseInit, streamOptions) => {
+    let body;
+    const isStream = result instanceof ReadableStream;
+    if (isStream) {
+        body = toSseStream(result, streamOptions);
+    }
+    else if (result instanceof Uint8Array) {
+        body = result;
+    }
+    else if (typeof result === "string") {
+        body = TEXT_ENCODER.encode(result);
+    }
+    else {
+        body = TEXT_ENCODER.encode(JSON.stringify(result));
+    }
+    if (!responseInit?.statusText) {
+        const status = responseInit?.status ?? 200;
+        const statusText = "OK";
+        const headers = responseInit?.headers;
+        responseInit = headers ? { status, statusText, headers } : { status, statusText };
+    }
+    const init = mergeResponseInit(isStream
+        ? {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache",
+            connection: "keep-alive",
+        }
+        : {
+            "content-type": "application/json",
+            "content-length": String(body.byteLength),
+        }, responseInit);
+    return new Response(body, init);
+};

package/dist/utils/stream.d.ts

@@ -0,0 +1,9 @@
+export type SseFrame<T = unknown, E extends string | undefined = string | undefined> = {
+    data: T;
+    event?: E;
+};
+export type SseErrorFrame = SseFrame<Error, "error" | undefined>;
+export declare function toSseStream(src: ReadableStream<SseFrame>, options?: {
+    onDone?: (status: number, reason?: unknown) => void;
+    keepAliveMs?: number;
+}): ReadableStream<Uint8Array>;

package/dist/utils/stream.js

@@ -0,0 +1,100 @@
+import { toOpenAIError } from "../errors/openai";
+const TEXT_ENCODER = new TextEncoder();
+const SSE_DONE_CHUNK = TEXT_ENCODER.encode("data: [DONE]\n\n");
+const SSE_KEEP_ALIVE_CHUNK = TEXT_ENCODER.encode(": keep-alive\n\n");
+const SSE_DEFAULT_KEEP_ALIVE_MS = 20_000;
+export function toSseStream(src, options = {}) {
+    const keepAliveMs = options.keepAliveMs ?? SSE_DEFAULT_KEEP_ALIVE_MS;
+    let reader;
+    let timer;
+    let finished = false;
+    const done = (controller, status, reason) => {
+        if (finished)
+            return;
+        finished = true;
+        if (timer)
+            clearTimeout(timer);
+        try {
+            options.onDone?.(status, reason);
+        }
+        catch { }
+        try {
+            controller.enqueue(SSE_DONE_CHUNK);
+        }
+        catch { }
+        try {
+            controller.close();
+        }
+        catch { }
+    };
+    const heartbeat = (controller) => {
+        if (timer)
+            clearTimeout(timer);
+        if (!keepAliveMs || keepAliveMs <= 0 || finished)
+            return;
+        timer = setTimeout(() => {
+            if (finished)
+                return;
+            try {
+                controller.enqueue(SSE_KEEP_ALIVE_CHUNK);
+                heartbeat(controller);
+            }
+            catch { }
+        }, keepAliveMs);
+    };
+    return new ReadableStream({
+        start(controller) {
+            reader = src.getReader();
+            heartbeat(controller);
+        },
+        async pull(controller) {
+            if (finished)
+                return;
+            try {
+                // oxlint-disable-next-line no-await-in-loop
+                const result = await reader.read();
+                if (result.done) {
+                    done(controller, 200);
+                    return;
+                }
+                const value = result.value;
+                if (value.event === "error" || value.data instanceof Error) {
+                    const error = toOpenAIError(value.data);
+                    controller.enqueue(TEXT_ENCODER.encode(serializeSseFrame({ event: value.event, data: error })));
+                    done(controller, error.error.type === "invalid_request_error" ? 422 : 502, value.data);
+                    reader.cancel(value.data).catch(() => { });
+                    return;
+                }
+                controller.enqueue(TEXT_ENCODER.encode(serializeSseFrame(value)));
+                heartbeat(controller);
+            }
+            catch (error) {
+                try {
+                    controller.enqueue(TEXT_ENCODER.encode(serializeSseFrame({
+                        event: "error",
+                        data: toOpenAIError(error),
+                    })));
+                }
+                catch { }
+                done(controller, 502, error);
+            }
+        },
+        cancel(reason) {
+            if (finished)
+                return;
+            finished = true;
+            if (timer)
+                clearTimeout(timer);
+            options.onDone?.(499, reason);
+            void reader?.cancel(reason).catch(() => { });
+        },
+    });
+}
+function serializeSseFrame(frame) {
+    let out = "";
+    if (frame.event) {
+        out += `event: ${frame.event}\n`;
+    }
+    out += `data: ${JSON.stringify(frame.data)}\n\n`;
+    return out;
+}

package/dist/utils/url.d.ts

@@ -0,0 +1,4 @@
+export declare const parseDataUrl: (url: string) => {
+    mimeType: string;
+    dataStart: number;
+};

package/dist/utils/url.js

@@ -0,0 +1,21 @@
+export const parseDataUrl = (url) => {
+    if (url.slice(0, 5).toLowerCase() !== "data:") {
+        return { mimeType: "", dataStart: 0 };
+    }
+    const MAX_HEADER_LENGTH = 1024;
+    const headerEnd = Math.min(url.length, 5 + MAX_HEADER_LENGTH);
+    const comma = url.indexOf(",", 5);
+    if (comma <= 5 || comma > headerEnd) {
+        return { mimeType: "", dataStart: 0 };
+    }
+    const semi = url.indexOf(";", 5);
+    const mimeEnd = semi !== -1 && semi < comma ? semi : comma;
+    const mimeType = url.slice(5, mimeEnd).trim();
+    if (!mimeType) {
+        return { mimeType: "", dataStart: 0 };
+    }
+    return {
+        mimeType,
+        dataStart: comma + 1,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
   "keywords": [
     "ai",