@hebo-ai/gateway 0.4.1 → 0.5.0-beta.0

package/dist/utils/response.d.ts

@@ -1,3 +1,3 @@
-export declare const prepareResponseInit: (request: Request) => ResponseInit;
+export declare const prepareResponseInit: (requestId: string) => ResponseInit;
 export declare const mergeResponseInit: (defaultHeaders: HeadersInit, responseInit?: ResponseInit) => ResponseInit;
 export declare const toResponse: (result: ReadableStream | Uint8Array<ArrayBuffer> | object | string, responseInit?: ResponseInit) => Response;

package/dist/utils/response.js

@@ -1,4 +1,4 @@
-import { REQUEST_ID_HEADER, resolveRequestId } from "./headers";
+import { REQUEST_ID_HEADER } from "./headers";
 const TEXT_ENCODER = new TextEncoder();
 class JsonToSseTransformStream extends TransformStream {
     constructor() {
@@ -12,8 +12,8 @@ class JsonToSseTransformStream extends TransformStream {
         });
     }
 }
-export const prepareResponseInit = (request) => ({
-    headers: { [REQUEST_ID_HEADER]: resolveRequestId(request) },
+export const prepareResponseInit = (requestId) => ({
+    headers: { [REQUEST_ID_HEADER]: requestId },
 });
 export const mergeResponseInit = (defaultHeaders, responseInit) => {
     const headers = new Headers(defaultHeaders);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.4.1",
+  "version": "0.5.0-beta.0",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
   "keywords": [
     "ai",
@@ -154,40 +154,38 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ai-sdk/provider": "^3.0.7",
-    "@ai-sdk/provider-utils": "^4.0.13",
-    "ai": "^6.0.67",
-    "serialize-error": "^13.0.1",
+    "@ai-sdk/provider": "^3.0.8",
+    "ai": "^6.0.94",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "^4.0.41",
-    "@ai-sdk/anthropic": "^3.0.31",
-    "@ai-sdk/cohere": "^3.0.16",
-    "@ai-sdk/google-vertex": "^4.0.37",
-    "@ai-sdk/groq": "^3.0.19",
-    "@ai-sdk/openai": "^3.0.23",
-    "@aws-sdk/credential-providers": "^3.981.0",
+    "@ai-sdk/amazon-bedrock": "^4.0.62",
+    "@ai-sdk/anthropic": "^3.0.46",
+    "@ai-sdk/cohere": "^3.0.21",
+    "@ai-sdk/google-vertex": "^4.0.61",
+    "@ai-sdk/groq": "^3.0.24",
+    "@ai-sdk/openai": "^3.0.30",
+    "@aws-sdk/credential-providers": "^3.994.0",
     "@langfuse/otel": "^4.6.1",
     "@mjackson/node-fetch-server": "^0.7.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-async-hooks": "^2.5.1",
     "@opentelemetry/sdk-trace-base": "^2.5.1",
-    "@tanstack/react-router": "^1.157.16",
-    "@tanstack/react-start": "^1.157.16",
+    "@tanstack/react-router": "^1.161.3",
+    "@tanstack/react-start": "^1.161.3",
     "@types/bun": "latest",
-    "@types/react": "^19.2.10",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "elysia": "^1.4.22",
-    "hono": "^4.11.7",
-    "lefthook": "^2.0.16",
+    "elysia": "^1.4.25",
+    "hono": "^4.12.0",
+    "lefthook": "^2.1.1",
     "next": "^16.1.6",
     "oxfmt": "^0.24.0",
-    "oxlint": "^1.42.0",
-    "pino": "^10.3.0",
+    "oxlint": "^1.49.0",
+    "pino": "^10.3.1",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
-    "vite-tsconfig-paths": "^6.0.5",
+    "vite-tsconfig-paths": "^6.1.1",
     "voyage-ai-provider": "^3.0.0"
   },
   "peerDependencies": {

package/src/endpoints/chat-completions/converters.test.ts

@@ -2,13 +2,116 @@ import type { GenerateTextResult, ToolSet, Output } from "ai";
 
 import { describe, expect, test } from "bun:test";
 
+import type { ChatCompletionsToolMessage } from "./schema";
+
 import {
   convertToTextCallOptions,
   toChatCompletionsAssistantMessage,
   fromChatCompletionsAssistantMessage,
+  fromChatCompletionsToolResultMessage,
 } from "./converters";
 
 describe("Chat Completions Converters", () => {
+  describe("fromChatCompletionsToolResultMessage", () => {
+    test("should handle tool message with string content", () => {
+      const assistantMessage = {
+        role: "assistant" as const,
+        tool_calls: [
+          {
+            id: "call_1",
+            type: "function" as const,
+            function: { name: "test_tool", arguments: "{}" },
+          },
+        ],
+      };
+      const toolById = new Map<string, ChatCompletionsToolMessage>([
+        ["call_1", { role: "tool", content: "hello world", tool_call_id: "call_1" }],
+      ]);
+
+      const result = fromChatCompletionsToolResultMessage(assistantMessage, toolById);
+      expect(result).toBeDefined();
+      expect(result?.content[0]).toMatchObject({
+        type: "tool-result",
+        toolCallId: "call_1",
+        output: { type: "text", value: "hello world" },
+      });
+    });
+
+    test("should handle tool message with content parts array", () => {
+      const assistantMessage = {
+        role: "assistant" as const,
+        tool_calls: [
+          {
+            id: "call_1",
+            type: "function" as const,
+            function: { name: "test_tool", arguments: "{}" },
+          },
+        ],
+      };
+      const toolById = new Map<string, ChatCompletionsToolMessage>([
+        [
+          "call_1",
+          {
+            role: "tool",
+            content: [
+              { type: "text", text: "part 1" },
+              { type: "text", text: " part 2" },
+            ],
+            tool_call_id: "call_1",
+          },
+        ],
+      ]);
+
+      const result = fromChatCompletionsToolResultMessage(assistantMessage, toolById);
+      expect(result).toBeDefined();
+      expect(result?.content[0]).toMatchObject({
+        type: "tool-result",
+        toolCallId: "call_1",
+        output: {
+          type: "content",
+          value: [
+            { type: "text", text: "part 1" },
+            { type: "text", text: " part 2" },
+          ],
+        },
+      });
+    });
+
+    test("should handle tool message with content parts array containing JSON string", () => {
+      const assistantMessage = {
+        role: "assistant" as const,
+        tool_calls: [
+          {
+            id: "call_1",
+            type: "function" as const,
+            function: { name: "test_tool", arguments: "{}" },
+          },
+        ],
+      };
+      const toolById = new Map<string, ChatCompletionsToolMessage>([
+        [
+          "call_1",
+          {
+            role: "tool",
+            content: [{ type: "text", text: '{"result": "success"}' }],
+            tool_call_id: "call_1",
+          },
+        ],
+      ]);
+
+      const result = fromChatCompletionsToolResultMessage(assistantMessage, toolById);
+      expect(result).toBeDefined();
+      expect(result?.content[0]).toMatchObject({
+        type: "tool-result",
+        toolCallId: "call_1",
+        output: {
+          type: "content",
+          value: [{ type: "text", text: '{"result": "success"}' }],
+        },
+      });
+    });
+  });
+
   describe("toChatCompletionsAssistantMessage", () => {
     test("should pass through providerMetadata to extra_content", () => {
       const mockResult: GenerateTextResult<ToolSet, Output.Output> = {
@@ -202,6 +305,37 @@ describe("Chat Completions Converters", () => {
         },
       });
     });
+
+    test("should handle both content and tool_calls", () => {
+      const message = fromChatCompletionsAssistantMessage({
+        role: "assistant",
+        content: "I will call a tool.",
+        tool_calls: [
+          {
+            id: "call_1",
+            type: "function",
+            function: {
+              name: "my_tool",
+              arguments: "{}",
+            },
+          },
+        ],
+      });
+
+      expect(Array.isArray(message.content)).toBe(true);
+      const content = message.content as any[];
+      expect(content).toHaveLength(2);
+      expect(content[0]).toEqual({
+        type: "text",
+        text: "I will call a tool.",
+      });
+      expect(content[1]).toEqual({
+        type: "tool-call",
+        toolCallId: "call_1",
+        toolName: "my_tool",
+        input: {},
+      });
+    });
   });
 
   describe("convertToTextCallOptions", () => {
@@ -236,5 +370,90 @@ describe("Chat Completions Converters", () => {
       });
       expect(result.maxOutputTokens).toBeUndefined();
     });
+
+    test("should convert response_format json_schema to output.object", async () => {
+      const result = convertToTextCallOptions({
+        messages: [{ role: "user", content: "hi" }],
+        response_format: {
+          type: "json_schema",
+          json_schema: {
+            name: "weather",
+            description: "Structured weather response",
+            schema: {
+              type: "object",
+              properties: {
+                city: { type: "string" },
+              },
+              required: ["city"],
+              additionalProperties: false,
+            },
+            strict: true,
+          },
+        },
+      });
+
+      expect(result.output?.name).toBe("object");
+
+      const parsed = await result.output!.parseCompleteOutput(
+        {
+          text: '{"city":"San Francisco"}',
+        },
+        {
+          response: {} as any,
+          usage: {} as any,
+          finishReason: "stop",
+        },
+      );
+
+      expect(parsed).toEqual({ city: "San Francisco" });
+    });
+
+    test("should treat response_format text as default text output", () => {
+      const result = convertToTextCallOptions({
+        messages: [{ role: "user", content: "hi" }],
+        response_format: {
+          type: "text",
+        },
+      });
+
+      expect(result.output).toBeUndefined();
+    });
+
+    test("should convert input_audio content parts to file user content", () => {
+      const result = convertToTextCallOptions({
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "input_audio",
+                input_audio: {
+                  data: "aGVsbG8=",
+                  format: "wav",
+                },
+              },
+            ],
+          },
+        ],
+      });
+
+      const userMessage = result.messages[0] as any;
+      expect(userMessage.role).toBe("user");
+      expect(Array.isArray(userMessage.content)).toBe(true);
+
+      const [part] = userMessage.content as any[];
+      expect(part.type).toBe("file");
+      expect(part.mediaType).toBe("audio/wav");
+      expect(part.data).toBeInstanceOf(Uint8Array);
+      expect(Array.from(part.data)).toEqual([104, 101, 108, 108, 111]);
+    });
+
+    test("should map tool_choice 'validated' to 'auto'", () => {
+      const result = convertToTextCallOptions({
+        messages: [{ role: "user", content: "hi" }],
+        tool_choice: "validated",
+      });
+      expect(result.toolChoice).toBe("auto");
+    });
   });
 });