@hebo-ai/gateway 0.6.2-rc1 → 0.7.0

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);
+            return 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.6.2-rc1",
+  "version": "0.7.0",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
   "keywords": [
     "ai",
@@ -179,6 +179,7 @@
     "@ai-sdk/amazon-bedrock": "^4.0.77",
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/cohere": "^3.0.25",
+    "@ai-sdk/google": "^3.0.43",
     "@ai-sdk/google-vertex": "^4.0.80",
     "@ai-sdk/groq": "^3.0.29",
     "@ai-sdk/openai": "^3.0.41",
@@ -196,6 +197,9 @@
     "@ai-sdk/cohere": {
       "optional": true
     },
+    "@ai-sdk/google": {
+      "optional": true
+    },
     "@ai-sdk/google-vertex": {
       "optional": true
     },

package/dist/telemetry/stream.d.ts

@@ -1,3 +0,0 @@
-export declare const wrapStream: (src: ReadableStream, hooks: {
-    onDone?: (status: number, reason: unknown) => void;
-}) => ReadableStream;

package/dist/telemetry/stream.js

@@ -1,58 +0,0 @@
-import { toOpenAIError } from "../errors/openai";
-const isErrorChunk = (v) => v instanceof Error || (typeof v === "object" && v !== null && "error" in v);
-export const wrapStream = (src, hooks) => {
-    let finished = false;
-    let reader;
-    const done = (controller, status, reason) => {
-        if (finished)
-            return;
-        finished = true;
-        hooks.onDone?.(status, reason);
-        if (status !== 200) {
-            reader?.cancel(reason).catch(() => { });
-        }
-        try {
-            controller.close();
-        }
-        catch { }
-    };
-    return new ReadableStream({
-        async start(controller) {
-            reader = src.getReader();
-            try {
-                for (;;) {
-                    // oxlint-disable-next-line no-await-in-loop, no-unsafe-assignment
-                    const { value, done: eof } = await reader.read();
-                    if (eof)
-                        break;
-                    controller.enqueue(value);
-                    if (isErrorChunk(value)) {
-                        done(controller, toOpenAIError(value).error.type === "invalid_request_error" ? 422 : 502, value);
-                        return;
-                    }
-                }
-                done(controller, 200);
-            }
-            catch (err) {
-                try {
-                    controller.enqueue(toOpenAIError(err));
-                }
-                catch { }
-                done(controller, 502, err);
-            }
-            finally {
-                try {
-                    reader?.releaseLock();
-                }
-                catch { }
-            }
-        },
-        cancel(reason) {
-            if (finished)
-                return;
-            finished = true;
-            hooks.onDone?.(499, reason);
-            reader?.cancel(reason).catch(() => { });
-        },
-    });
-};