@hebo-ai/gateway 0.5.0 → 0.5.2

package/README.md

@@ -660,9 +660,9 @@ const gw = gateway({
   // ...
   telemetry: {
     enabled: true,
-    tracer = new BasicTracerProvider({
+    tracer: new BasicTracerProvider({
       spanProcessors: [new LangfuseSpanProcessor()],
-    }).getTracer("hebo");,
+    }).getTracer("hebo"),
   },
 });
 ```

package/dist/config.js

@@ -1,5 +1,6 @@
 import { isLogger, logger, setLoggerInstance } from "./logger";
 import { createDefaultLogger } from "./logger/default";
+import { installAiSdkWarningLogger } from "./telemetry/ai-sdk";
 import { kParsed, } from "./types";
 export const parseConfig = (config) => {
     // If it has been parsed before, just return.
@@ -64,6 +65,7 @@ export const parseConfig = (config) => {
             gen_ai: "off",
             hebo: "off",
         };
+    installAiSdkWarningLogger(telemetrySignals.gen_ai);
     // Return parsed config.
     return {
         ...config,

package/dist/endpoints/chat-completions/converters.d.ts

@@ -7,6 +7,7 @@ export type TextCallOptions = {
     messages: ModelMessage[];
     tools?: ToolSet;
     toolChoice?: ToolChoice<ToolSet>;
+    activeTools?: Array<keyof ToolSet>;
     output?: Output.Output;
     temperature?: number;
     maxOutputTokens?: number;
@@ -24,7 +25,10 @@ export declare function fromChatCompletionsAssistantMessage(message: ChatComplet
 export declare function fromChatCompletionsToolResultMessage(message: ChatCompletionsAssistantMessage, toolById: Map<string, ChatCompletionsToolMessage>): ToolModelMessage | undefined;
 export declare function fromChatCompletionsContent(content: ChatCompletionsContentPart[]): UserContent;
 export declare const convertToToolSet: (tools: ChatCompletionsTool[] | undefined) => ToolSet | undefined;
-export declare const convertToToolChoice: (toolChoice: ChatCompletionsToolChoice | undefined) => ToolChoice<ToolSet> | undefined;
+export declare const convertToToolChoiceOptions: (toolChoice: ChatCompletionsToolChoice | undefined) => {
+    toolChoice?: ToolChoice<ToolSet>;
+    activeTools?: Array<keyof ToolSet>;
+};
 export declare function toChatCompletions(result: GenerateTextResult<ToolSet, Output.Output>, model: string): ChatCompletions;
 export declare function toChatCompletionsResponse(result: GenerateTextResult<ToolSet, Output.Output>, model: string, responseInit?: ResponseInit): Response;
 export declare function toChatCompletionsStream<E extends boolean = false>(result: StreamTextResult<ToolSet, Output.Output>, model: string, wrapErrors?: E): ReadableStream<ChatCompletionsChunk | (E extends true ? OpenAIError : Error)>;

package/dist/endpoints/chat-completions/converters.js

@@ -7,10 +7,12 @@ import { toResponse } from "../../utils/response";
 export function convertToTextCallOptions(params) {
     const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, response_format, reasoning_effort, reasoning, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
     Object.assign(rest, parseReasoningOptions(reasoning_effort, reasoning));
+    const { toolChoice, activeTools } = convertToToolChoiceOptions(tool_choice);
     return {
         messages: convertToModelMessages(messages),
         tools: convertToToolSet(tools),
-        toolChoice: convertToToolChoice(tool_choice),
+        toolChoice,
+        activeTools,
         output: convertToOutput(response_format),
         temperature,
         maxOutputTokens: max_completion_tokens ?? max_tokens,
@@ -207,24 +209,33 @@ export const convertToToolSet = (tools) => {
         toolSet[t.function.name] = tool({
             description: t.function.description,
             inputSchema: jsonSchema(t.function.parameters),
+            strict: t.function.strict,
         });
     }
     return toolSet;
 };
-export const convertToToolChoice = (toolChoice) => {
+export const convertToToolChoiceOptions = (toolChoice) => {
     if (!toolChoice) {
-        return undefined;
+        return {};
     }
     if (toolChoice === "none" || toolChoice === "auto" || toolChoice === "required") {
-        return toolChoice;
+        return { toolChoice };
     }
     // FUTURE: this is right now google specific, which is not supported by AI SDK, until then, we temporarily map it to auto for now https://docs.cloud.google.com/vertex-ai/generative-ai/docs/migrate/openai/overview
     if (toolChoice === "validated") {
-        return "auto";
+        return { toolChoice: "auto" };
+    }
+    if (toolChoice.type === "allowed_tools") {
+        return {
+            toolChoice: toolChoice.allowed_tools.mode,
+            activeTools: toolChoice.allowed_tools.tools.map((toolRef) => toolRef.function.name),
+        };
     }
     return {
-        type: "tool",
-        toolName: toolChoice.function.name,
+        toolChoice: {
+            type: "tool",
+            toolName: toolChoice.function.name,
+        },
     };
 };
 function parseToolResult(content) {
@@ -409,9 +420,12 @@ export const toChatCompletionsAssistantMessage = (result) => {
         if (part.type === "text") {
             if (message.content === null) {
                 message.content = part.text;
-                if (part.providerMetadata) {
-                    message.extra_content = part.providerMetadata;
-                }
+            }
+            else {
+                message.content += part.text;
+            }
+            if (part.providerMetadata) {
+                message.extra_content = part.providerMetadata;
             }
         }
         else if (part.type === "reasoning") {
@@ -427,6 +441,10 @@ export const toChatCompletionsAssistantMessage = (result) => {
     if (reasoningDetails.length > 0) {
         message.reasoning_details = reasoningDetails;
     }
+    if (!message.content && !message.tool_calls) {
+        // some models return just reasoning without tool calls or content
+        message.content = "";
+    }
     return message;
 };
 export function toReasoningDetail(reasoning, id, index) {
@@ -485,8 +503,8 @@ export function toChatCompletionsToolCall(id, name, args, providerMetadata) {
         id,
         type: "function",
         function: {
-            name,
-            arguments: typeof args === "string" ? args : JSON.stringify(args),
+            name: normalizeToolName(name),
+            arguments: typeof args === "string" ? args : JSON.stringify(stripEmptyKeys(args)),
         },
     };
     if (providerMetadata) {
@@ -494,6 +512,37 @@ export function toChatCompletionsToolCall(id, name, args, providerMetadata) {
     }
     return out;
 }
+function normalizeToolName(name) {
+    // some models hallucinate invalid characters
+    // normalize to valid characters [^A-Za-z0-9_-.] (non regex for perf)
+    // https://modelcontextprotocol.io/specification/draft/server/tools#tool-names
+    let out = "";
+    for (let i = 0; i < name.length; i++) {
+        if (out.length === 128)
+            break;
+        // eslint-disable-next-line unicorn/prefer-code-point
+        const c = name.charCodeAt(i);
+        if ((c >= 48 && c <= 57) ||
+            (c >= 65 && c <= 90) ||
+            (c >= 97 && c <= 122) ||
+            c === 95 ||
+            c === 45 ||
+            c === 46) {
+            out += name[i];
+        }
+        else {
+            out += "_";
+        }
+    }
+    return out;
+}
+function stripEmptyKeys(obj) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj))
+        return obj;
+    // some models hallucinate empty parameters
+    delete obj[""];
+    return obj;
+}
 export const toChatCompletionsFinishReason = (finishReason) => {
     if (finishReason === "error" || finishReason === "other") {
         return "stop";

package/dist/endpoints/chat-completions/schema.d.ts

@@ -281,20 +281,35 @@ export declare const ChatCompletionsToolSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        strict: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ChatCompletionsTool = z.infer<typeof ChatCompletionsToolSchema>;
 export declare const ChatCompletionsToolChoiceSchema: z.ZodUnion<readonly [z.ZodEnum<{
     auto: "auto";
-    none: "none";
     required: "required";
+    none: "none";
     validated: "validated";
-}>, z.ZodObject<{
+}>, z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"function">;
     function: z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>;
-}, z.core.$strip>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"allowed_tools">;
+    allowed_tools: z.ZodObject<{
+        mode: z.ZodEnum<{
+            auto: "auto";
+            required: "required";
+        }>;
+        tools: z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">]>;
 export type ChatCompletionsToolChoice = z.infer<typeof ChatCompletionsToolChoiceSchema>;
 export declare const ChatCompletionsReasoningEffortSchema: z.ZodEnum<{
     low: "low";
@@ -434,19 +449,34 @@ declare const ChatCompletionsInputsSchema: z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            strict: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
     }, z.core.$strip>>>;
     tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         auto: "auto";
-        none: "none";
         required: "required";
+        none: "none";
         validated: "validated";
-    }>, z.ZodObject<{
+    }>, z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"function">;
         function: z.ZodObject<{
             name: z.ZodString;
         }, z.core.$strip>;
-    }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"allowed_tools">;
+        allowed_tools: z.ZodObject<{
+            mode: z.ZodEnum<{
+                auto: "auto";
+                required: "required";
+            }>;
+            tools: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     max_tokens: z.ZodOptional<z.ZodInt>;
     max_completion_tokens: z.ZodOptional<z.ZodInt>;
@@ -580,19 +610,34 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            strict: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
     }, z.core.$strip>>>;
     tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         auto: "auto";
-        none: "none";
         required: "required";
+        none: "none";
         validated: "validated";
-    }>, z.ZodObject<{
+    }>, z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"function">;
         function: z.ZodObject<{
             name: z.ZodString;
         }, z.core.$strip>;
-    }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"allowed_tools">;
+        allowed_tools: z.ZodObject<{
+            mode: z.ZodEnum<{
+                auto: "auto";
+                required: "required";
+            }>;
+            tools: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     max_tokens: z.ZodOptional<z.ZodInt>;
     max_completion_tokens: z.ZodOptional<z.ZodInt>;

package/dist/endpoints/chat-completions/schema.js

@@ -113,18 +113,29 @@ export const ChatCompletionsToolSchema = z.object({
         name: z.string(),
         description: z.string().optional(),
         parameters: z.record(z.string(), z.unknown()),
-        // Missing strict parameter
+        strict: z.boolean().optional(),
+    }),
+});
+const ChatCompletionsNamedFunctionToolChoiceSchema = z.object({
+    type: z.literal("function"),
+    function: z.object({
+        name: z.string(),
+    }),
+});
+const ChatCompletionsAllowedFunctionToolChoiceSchema = z.object({
+    type: z.literal("allowed_tools"),
+    allowed_tools: z.object({
+        mode: z.enum(["auto", "required"]),
+        tools: z.array(ChatCompletionsNamedFunctionToolChoiceSchema).nonempty(),
     }),
 });
 export const ChatCompletionsToolChoiceSchema = z.union([
     z.enum(["none", "auto", "required", "validated"]),
-    // FUTURE: missing AllowedTools and CustomToolChoice
-    z.object({
-        type: z.literal("function"),
-        function: z.object({
-            name: z.string(),
-        }),
-    }),
+    z.discriminatedUnion("type", [
+        ChatCompletionsNamedFunctionToolChoiceSchema,
+        ChatCompletionsAllowedFunctionToolChoiceSchema,
+    ]),
+    // FUTURE: Missing CustomTool
 ]);
 export const ChatCompletionsReasoningEffortSchema = z.enum([
     "none",
@@ -161,11 +172,7 @@ export const ChatCompletionsResponseFormatSchema = z.discriminatedUnion("type",
 ]);
 const ChatCompletionsInputsSchema = z.object({
     messages: z.array(ChatCompletionsMessageSchema),
-    tools: z
-        .array(
-    // FUTURE: Missing CustomTool
-    ChatCompletionsToolSchema)
-        .optional(),
+    tools: z.array(ChatCompletionsToolSchema).optional(),
     tool_choice: ChatCompletionsToolChoiceSchema.optional(),
     temperature: z.number().min(0).max(2).optional(),
     max_tokens: z.int().nonnegative().optional(),

package/dist/models/anthropic/middleware.js

@@ -5,11 +5,11 @@ const isClaude = (family, version) => {
     return (modelId) => modelId.includes(`claude-${family}-${version}`) ||
         modelId.includes(`claude-${family}-${dashed}`);
 };
+const isClaude4 = (modelId) => modelId.includes("claude-") && modelId.includes("-4");
 const isOpus46 = isClaude("opus", "4.6");
 const isOpus45 = isClaude("opus", "4.5");
 const isOpus4 = isClaude("opus", "4");
 const isSonnet46 = isClaude("sonnet", "4.6");
-const isSonnet45 = isClaude("sonnet", "4.5");
 export function mapClaudeReasoningEffort(effort, modelId) {
     if (isOpus46(modelId)) {
         switch (effort) {
@@ -48,7 +48,10 @@ function getMaxOutputTokens(modelId) {
         return 32_000;
     return 64_000;
 }
+// Documentation:
 // https://platform.claude.com/docs/en/build-with-claude/effort
+// https://platform.claude.com/docs/en/build-with-claude/extended-thinking
+// https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking
 export const claudeReasoningMiddleware = {
     specificationVersion: "v3",
     // eslint-disable-next-line require-await
@@ -66,30 +69,28 @@ export const claudeReasoningMiddleware = {
             target["thinking"] = { type: "disabled" };
         }
         else if (reasoning.effort) {
+            if (isClaude4(modelId)) {
+                target["effort"] = mapClaudeReasoningEffort(reasoning.effort, modelId);
+            }
             if (isOpus46(modelId)) {
                 target["thinking"] = clampedMaxTokens
                     ? { type: "adaptive", budgetTokens: clampedMaxTokens }
                     : { type: "adaptive" };
-                target["effort"] = mapClaudeReasoningEffort(reasoning.effort, modelId);
             }
             else if (isSonnet46(modelId)) {
                 target["thinking"] = clampedMaxTokens
                     ? { type: "enabled", budgetTokens: clampedMaxTokens }
                     : { type: "adaptive" };
-                target["effort"] = mapClaudeReasoningEffort(reasoning.effort, modelId);
             }
-            else if (isOpus45(modelId) || isSonnet45(modelId)) {
+            else {
                 target["thinking"] = { type: "enabled" };
-                if (clampedMaxTokens)
+                if (clampedMaxTokens) {
                     target["thinking"]["budgetTokens"] = clampedMaxTokens;
-                target["effort"] = mapClaudeReasoningEffort(reasoning.effort, modelId);
-            }
-            else {
-                // FUTURE: warn that reasoning.max_tokens was computed
-                target["thinking"] = {
-                    type: "enabled",
-                    budgetTokens: calculateReasoningBudgetFromEffort(reasoning.effort, params.maxOutputTokens ?? getMaxOutputTokens(modelId), 1024),
-                };
+                }
+                else {
+                    // FUTURE: warn that reasoning.max_tokens was computed
+                    target["thinking"]["budgetTokens"] = calculateReasoningBudgetFromEffort(reasoning.effort, params.maxOutputTokens ?? getMaxOutputTokens(modelId), 1024);
+                }
             }
         }
         else if (clampedMaxTokens) {

package/dist/providers/bedrock/middleware.d.ts

@@ -1,2 +1,3 @@
 import type { LanguageModelMiddleware } from "ai";
-export declare const bedrockAnthropicReasoningMiddleware: LanguageModelMiddleware;
+export declare const bedrockGptReasoningMiddleware: LanguageModelMiddleware;
+export declare const bedrockClaudeReasoningMiddleware: LanguageModelMiddleware;

package/dist/providers/bedrock/middleware.js

@@ -1,5 +1,24 @@
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
-export const bedrockAnthropicReasoningMiddleware = {
+const isClaude46 = (modelId) => modelId.includes("-4-6");
+export const bedrockGptReasoningMiddleware = {
+    specificationVersion: "v3",
+    // eslint-disable-next-line require-await
+    transformParams: async ({ params, model }) => {
+        if (!model.modelId.includes("gpt"))
+            return params;
+        const bedrock = params.providerOptions?.["bedrock"];
+        if (!bedrock || typeof bedrock !== "object")
+            return params;
+        const effort = bedrock["reasoningEffort"];
+        if (effort === undefined)
+            return params;
+        const target = (bedrock["reasoningConfig"] ??= {});
+        target["maxReasoningEffort"] = effort;
+        delete bedrock["reasoningEffort"];
+        return params;
+    },
+};
+export const bedrockClaudeReasoningMiddleware = {
     specificationVersion: "v3",
     // eslint-disable-next-line require-await
     transformParams: async ({ params, model }) => {
@@ -8,12 +27,11 @@ export const bedrockAnthropicReasoningMiddleware = {
         const bedrock = params.providerOptions?.["bedrock"];
         if (!bedrock || typeof bedrock !== "object")
             return params;
-        const bedrockOptions = bedrock;
-        const thinking = bedrockOptions["thinking"];
-        const effort = bedrockOptions["effort"];
+        const thinking = bedrock["thinking"];
+        const effort = bedrock["effort"];
         if (!thinking && effort === undefined)
             return params;
-        const target = (bedrockOptions["reasoningConfig"] ??= {});
+        const target = (bedrock["reasoningConfig"] ??= {});
         if (thinking && typeof thinking === "object") {
             const thinkingOptions = thinking;
             if (thinkingOptions["type"] !== undefined) {
@@ -23,13 +41,15 @@ export const bedrockAnthropicReasoningMiddleware = {
                 target["budgetTokens"] = thinkingOptions["budgetTokens"];
             }
         }
-        if (effort !== undefined)
+        // FUTURE: bedrock currently does not support "effort" for other 4.x models
+        if (effort !== undefined && isClaude46(model.modelId)) {
             target["maxReasoningEffort"] = effort;
-        delete bedrockOptions["thinking"];
-        delete bedrockOptions["effort"];
+        }
+        delete bedrock["thinking"];
+        delete bedrock["effort"];
         return params;
     },
 };
 modelMiddlewareMatcher.useForProvider("amazon-bedrock", {
-    language: [bedrockAnthropicReasoningMiddleware],
+    language: [bedrockGptReasoningMiddleware, bedrockClaudeReasoningMiddleware],
 });

package/dist/telemetry/ai-sdk.d.ts

@@ -0,0 +1,2 @@
+import type { TelemetrySignalLevel } from "../types";
+export declare const installAiSdkWarningLogger: (genAiSignalLevel?: TelemetrySignalLevel) => void;

package/dist/telemetry/ai-sdk.js

@@ -0,0 +1,31 @@
+import { logger } from "../logger";
+import { addSpanEvent, setSpanAttributes } from "./span";
+export const installAiSdkWarningLogger = (genAiSignalLevel) => {
+    const logWarnings = ({ warnings, provider, model }) => {
+        if (warnings.length === 0)
+            return;
+        for (const warning of warnings) {
+            logger.warn({
+                provider,
+                model,
+                warning,
+            }, `[ai-sdk] ${warning.type}`);
+        }
+        if (!(genAiSignalLevel === "recommended" || genAiSignalLevel === "full"))
+            return;
+        setSpanAttributes({
+            "gen_ai.response.warning_count": warnings.length,
+        });
+        for (const warning of warnings) {
+            addSpanEvent("gen_ai.warning", {
+                "gen_ai.provider.name": provider,
+                "gen_ai.response.model": model,
+                "gen_ai.warning.type": warning.type,
+                "gen_ai.warning.feature": "feature" in warning ? warning.feature : undefined,
+                "gen_ai.warning.details": "details" in warning ? warning.details : undefined,
+                "gen_ai.warning.message": "message" in warning ? warning.message : undefined,
+            });
+        }
+    };
+    globalThis.AI_SDK_LOG_WARNINGS = logWarnings;
+};

package/package.json

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

package/src/config.ts

@@ -1,5 +1,6 @@
 import { isLogger, logger, setLoggerInstance } from "./logger";
 import { createDefaultLogger } from "./logger/default";
+import { installAiSdkWarningLogger } from "./telemetry/ai-sdk";
 import {
   kParsed,
   type GatewayConfig,
@@ -80,6 +81,8 @@ export const parseConfig = (config: GatewayConfig): GatewayConfigParsed => {
           hebo: "off",
         };
 
+  installAiSdkWarningLogger(telemetrySignals.gen_ai);
+
   // Return parsed config.
   return {
     ...config,

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

@@ -7,6 +7,7 @@ import type { ChatCompletionsToolMessage } from "./schema";
 import {
   convertToTextCallOptions,
   toChatCompletionsAssistantMessage,
+  toChatCompletionsToolCall,
   fromChatCompletionsAssistantMessage,
   fromChatCompletionsToolResultMessage,
 } from "./converters";
@@ -455,5 +456,115 @@ describe("Chat Completions Converters", () => {
       });
       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"]);
+    });
+  });
+
+  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));
+    });
   });
 });