@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

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

@@ -1,631 +0,0 @@
-import type { GenerateTextResult, ToolSet, Output, LanguageModelUsage } from "ai";
-
-import { describe, expect, test } from "bun:test";
-
-import type { ChatCompletionsToolMessage } from "./schema";
-
-import {
-  convertToTextCallOptions,
-  toChatCompletionsAssistantMessage,
-  toChatCompletionsToolCall,
-  toChatCompletionsUsage,
-  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> = {
-        content: [
-          {
-            type: "text",
-            text: "hello",
-            providerMetadata: {
-              vertex: {
-                thought_signature: "signature-abc",
-              },
-            },
-          } as any,
-        ],
-        toolCalls: [],
-      };
-
-      const message = toChatCompletionsAssistantMessage(mockResult);
-
-      expect(message.extra_content).toEqual({
-        vertex: {
-          thought_signature: "signature-abc",
-        },
-      });
-    });
-
-    test("should pass through providerMetadata to tool calls", () => {
-      const mockResult: GenerateTextResult<ToolSet, Output.Output> = {
-        content: [],
-        toolCalls: [
-          {
-            toolCallId: "call_123",
-            toolName: "get_weather",
-            input: { location: "London" },
-            providerMetadata: {
-              vertex: { thought_signature: "tool-signature" },
-            },
-          },
-        ],
-      };
-
-      const message = toChatCompletionsAssistantMessage(mockResult);
-
-      expect(message.tool_calls![0].extra_content).toEqual({
-        vertex: { thought_signature: "tool-signature" },
-      });
-    });
-
-    test("should extract reasoning_details from reasoning parts", () => {
-      const mockResult: GenerateTextResult<ToolSet, Output.Output> = {
-        content: [
-          {
-            type: "reasoning",
-            text: "I am thinking...",
-            providerMetadata: {
-              anthropic: {
-                signature: "sig-123",
-              },
-            },
-          } as any,
-          {
-            type: "text",
-            text: "Final answer.",
-          } as any,
-        ],
-        reasoningText: "I am thinking...",
-        toolCalls: [],
-      };
-
-      const message = toChatCompletionsAssistantMessage(mockResult);
-
-      expect(message.reasoning).toBe("I am thinking...");
-      expect(message.reasoning_details![0]).toMatchObject({
-        type: "reasoning.text",
-        text: "I am thinking...",
-        signature: "sig-123",
-        format: "unknown",
-        index: 0,
-      });
-      expect(message.reasoning_details![0].id).toStartWith("reasoning-");
-      expect(message.content).toBe("Final answer.");
-    });
-
-    test("should handle redacted/encrypted reasoning", () => {
-      const mockResult: GenerateTextResult<ToolSet, Output.Output> = {
-        content: [
-          {
-            type: "reasoning",
-            text: "",
-            providerMetadata: {
-              anthropic: {
-                redactedData: "encrypted-content",
-              },
-            },
-          } as any,
-        ],
-        toolCalls: [],
-      };
-
-      const message = toChatCompletionsAssistantMessage(mockResult);
-
-      expect(message.reasoning_details![0]).toMatchObject({
-        type: "reasoning.encrypted",
-        data: "encrypted-content",
-      });
-      expect((message.reasoning_details![0] as any).text).toBeUndefined();
-      expect(message.reasoning_details![0].signature).toBeUndefined();
-    });
-  });
-
-  describe("fromChatCompletionsAssistantMessage", () => {
-    test("should convert reasoning_details back to reasoning parts with unknown providerOptions", () => {
-      const message = fromChatCompletionsAssistantMessage({
-        role: "assistant",
-        content: "The result is 42.",
-        reasoning_details: [
-          {
-            type: "reasoning.text",
-            text: "Thinking hard...",
-            signature: "sig-xyz",
-            format: "unknown",
-            index: 0,
-          },
-        ],
-      });
-
-      expect(Array.isArray(message.content)).toBe(true);
-      const content = message.content as any[];
-      expect(content).toHaveLength(2);
-      expect(content[0]).toEqual({
-        type: "reasoning",
-        text: "Thinking hard...",
-        providerOptions: {
-          unknown: {
-            signature: "sig-xyz",
-          },
-        },
-      });
-      expect(content[1]).toEqual({
-        type: "text",
-        text: "The result is 42.",
-      });
-    });
-
-    test("should convert reasoning.encrypted back to reasoning parts", () => {
-      const message = fromChatCompletionsAssistantMessage({
-        role: "assistant",
-        content: "Hello",
-        reasoning_details: [
-          {
-            type: "reasoning.encrypted",
-            data: "secret-data",
-            format: "unknown",
-            index: 0,
-          },
-        ],
-      });
-
-      expect(Array.isArray(message.content)).toBe(true);
-      const content = message.content as any[];
-      expect(content[0]).toEqual({
-        type: "reasoning",
-        text: "",
-        providerOptions: {
-          unknown: {
-            redactedData: "secret-data",
-          },
-        },
-      });
-    });
-
-    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", () => {
-    test("should use max_completion_tokens when present", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-        max_completion_tokens: 200,
-      });
-      expect(result.maxOutputTokens).toBe(200);
-    });
-
-    test("should use max_tokens when max_completion_tokens is absent", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-        max_tokens: 100,
-      });
-      expect(result.maxOutputTokens).toBe(100);
-    });
-
-    test("should favor max_completion_tokens over max_tokens when both are present", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-        max_tokens: 100,
-        max_completion_tokens: 200,
-      });
-      expect(result.maxOutputTokens).toBe(200);
-    });
-
-    test("should handle neither being present", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-      });
-      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");
-    });
-
-    test("should map allowed_tools to activeTools and auto mode", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-        tool_choice: {
-          type: "allowed_tools",
-          allowed_tools: {
-            mode: "auto",
-            tools: [
-              {
-                type: "function",
-                function: { name: "get_weather" },
-              },
-            ],
-          },
-        },
-      });
-
-      expect(result.toolChoice).toBe("auto");
-      expect(result.activeTools).toEqual(["get_weather"]);
-    });
-
-    test("should map allowed_tools required mode to required", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-        tool_choice: {
-          type: "allowed_tools",
-          allowed_tools: {
-            mode: "required",
-            tools: [
-              {
-                type: "function",
-                function: { name: "get_weather" },
-              },
-            ],
-          },
-        },
-      });
-
-      expect(result.toolChoice).toBe("required");
-      expect(result.activeTools).toEqual(["get_weather"]);
-    });
-
-    test("should convert function tools into tool set entries", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "user", content: "hi" }],
-        tools: [
-          {
-            type: "function",
-            function: {
-              name: "get_weather",
-              description: "Get weather",
-              parameters: {
-                type: "object",
-                properties: {},
-              },
-            },
-          },
-        ],
-      });
-
-      expect(result.tools).toBeDefined();
-      expect(Object.keys(result.tools!)).toEqual(["get_weather"]);
-    });
-
-    test("should map prompt cache options into providerOptions.unknown", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "system", content: "You are concise." }],
-        prompt_cache_key: "tenant:docs:v1",
-        prompt_cache_retention: "24h",
-      });
-
-      expect(result.providerOptions).toEqual({
-        unknown: {
-          prompt_cache_key: "tenant:docs:v1",
-          prompt_cache_retention: "24h",
-          cached_content: "tenant:docs:v1",
-          cache_control: {
-            type: "ephemeral",
-            ttl: "24h",
-          },
-        },
-      });
-    });
-
-    test("should sync retention from cache_control ttl", () => {
-      const result = convertToTextCallOptions({
-        messages: [{ role: "system", content: "You are concise." }],
-        cache_control: {
-          type: "ephemeral",
-          ttl: "5m",
-        },
-      });
-
-      expect(result.providerOptions).toEqual({
-        unknown: {
-          prompt_cache_retention: "in_memory",
-          cache_control: {
-            type: "ephemeral",
-            ttl: "5m",
-          },
-        },
-      });
-    });
-
-    test("should preserve cache_control on message and content parts", () => {
-      const result = convertToTextCallOptions({
-        messages: [
-          {
-            role: "system",
-            content: "Policy block",
-            cache_control: { type: "ephemeral", ttl: "1h" },
-          },
-          {
-            role: "user",
-            content: [{ type: "text", text: "Question", cache_control: { type: "ephemeral" } }],
-          },
-        ],
-      });
-
-      expect((result.messages[0] as any).providerOptions.unknown.cache_control).toEqual({
-        type: "ephemeral",
-        ttl: "1h",
-      });
-      expect((result.messages[1] as any).content[0].providerOptions.unknown.cache_control).toEqual({
-        type: "ephemeral",
-      });
-    });
-  });
-
-  describe("toChatCompletionsUsage", () => {
-    test("should include cached token details", () => {
-      const usage = toChatCompletionsUsage({
-        inputTokens: 100,
-        outputTokens: 20,
-        totalTokens: 120,
-        inputTokenDetails: {
-          cacheReadTokens: 60,
-          cacheWriteTokens: 10,
-        },
-      } as LanguageModelUsage);
-
-      expect(usage.prompt_tokens_details).toEqual({
-        cached_tokens: 60,
-        cache_write_tokens: 10,
-      });
-    });
-  });
-
-  describe("toChatCompletionsToolCall", () => {
-    test("should filter top-level empty-string keys from object arguments", () => {
-      const call = toChatCompletionsToolCall("call_1", "my_tool", {
-        "": {},
-        city: "San Francisco",
-        nested: {
-          "": {},
-          country: "US",
-        },
-      });
-
-      expect(call.function.arguments).toBe(
-        JSON.stringify({
-          city: "San Francisco",
-          nested: {
-            "": {},
-            country: "US",
-          },
-        }),
-      );
-    });
-
-    test("should pass through JSON string arguments unchanged", () => {
-      const call = toChatCompletionsToolCall(
-        "call_1",
-        "my_tool",
-        '{"":{},"city":"San Francisco","nested":{"":{},"country":"US"}}',
-      );
-
-      expect(call.function.arguments).toBe(
-        '{"":{},"city":"San Francisco","nested":{"":{},"country":"US"}}',
-      );
-    });
-
-    test("should normalize invalid tool names", () => {
-      const call = toChatCompletionsToolCall("call_1", "bad. Tool- name1!@", {});
-      expect(call.function.name).toBe("bad._Tool-_name1__");
-    });
-
-    test("should truncate tool names longer than 128 chars", () => {
-      const call = toChatCompletionsToolCall("call_1", "a".repeat(200), {});
-      expect(call.function.name).toHaveLength(128);
-      expect(call.function.name).toBe("a".repeat(128));
-    });
-  });
-});