@hebo-ai/gateway 0.5.0 → 0.5.1

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.1",
   "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));
+    });
   });
 });

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

@@ -56,6 +56,7 @@ export type TextCallOptions = {
   messages: ModelMessage[];
   tools?: ToolSet;
   toolChoice?: ToolChoice<ToolSet>;
+  activeTools?: Array<keyof ToolSet>;
   output?: Output.Output;
   temperature?: number;
   maxOutputTokens?: number;
@@ -90,10 +91,13 @@ export function convertToTextCallOptions(params: ChatCompletionsInputs): TextCal
 
   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,
@@ -321,30 +325,43 @@ export const convertToToolSet = (tools: ChatCompletionsTool[] | undefined): Tool
     toolSet[t.function.name] = tool({
       description: t.function.description,
       inputSchema: jsonSchema(t.function.parameters),
+      strict: t.function.strict,
     });
   }
   return toolSet;
 };
 
-export const convertToToolChoice = (
+export const convertToToolChoiceOptions = (
   toolChoice: ChatCompletionsToolChoice | undefined,
-): ToolChoice<ToolSet> | undefined => {
+): {
+  toolChoice?: ToolChoice<ToolSet>;
+  activeTools?: Array<keyof ToolSet>;
+} => {
   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,
+    },
   };
 };
 
@@ -617,9 +634,11 @@ export const toChatCompletionsAssistantMessage = (
     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") {
       reasoningDetails.push(
@@ -646,6 +665,11 @@ export const toChatCompletionsAssistantMessage = (
     message.reasoning_details = reasoningDetails;
   }
 
+  if (!message.content && !message.tool_calls) {
+    // some models return just reasoning without tool calls or content
+    message.content = "";
+  }
+
   return message;
 };
 
@@ -722,8 +746,8 @@ export function toChatCompletionsToolCall(
     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)),
     },
   };
 
@@ -734,6 +758,40 @@ export function toChatCompletionsToolCall(
   return out;
 }
 
+function normalizeToolName(name: string): string {
+  // 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: unknown) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+  // some models hallucinate empty parameters
+  delete (obj as Record<string, unknown>)[""];
+  return obj;
+}
+
 export const toChatCompletionsFinishReason = (
   finishReason: FinishReason,
 ): ChatCompletionsFinishReason => {

package/src/endpoints/chat-completions/schema.ts

@@ -135,20 +135,33 @@ 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(),
   }),
 });
 export type ChatCompletionsTool = z.infer<typeof ChatCompletionsToolSchema>;
 
+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 type ChatCompletionsToolChoice = z.infer<typeof ChatCompletionsToolChoiceSchema>;
 
@@ -193,12 +206,7 @@ export type ChatCompletionsResponseFormat = z.infer<typeof ChatCompletionsRespon
 
 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/src/models/anthropic/middleware.test.ts

@@ -125,7 +125,7 @@ test("claudeReasoningMiddleware > should transform reasoning object to thinking
       anthropic: {
         thinking: {
           type: "enabled",
-          budgetTokens: 32000,
+          budgetTokens: 2000,
         },
       },
       unknown: {},
@@ -412,6 +412,7 @@ test("claudeReasoningMiddleware > should map none effort to low for Claude Sonne
 
   expect(result.providerOptions?.anthropic?.thinking).toEqual({
     type: "enabled",
+    budgetTokens: 1024,
   });
   expect(result.providerOptions?.anthropic?.effort).toBe("low");
 });
@@ -518,6 +519,7 @@ test("claudeReasoningMiddleware > should map max effort to high for Claude Sonne
 
   expect(result.providerOptions?.anthropic?.thinking).toEqual({
     type: "enabled",
+    budgetTokens: 60800,
   });
   expect(result.providerOptions?.anthropic?.effort).toBe("high");
 });
@@ -543,6 +545,7 @@ test("claudeReasoningMiddleware > should map xhigh effort to high for Claude Son
 
   expect(result.providerOptions?.anthropic?.thinking).toEqual({
     type: "enabled",
+    budgetTokens: 60800,
   });
   expect(result.providerOptions?.anthropic?.effort).toBe("high");
 });
@@ -590,6 +593,7 @@ test("claudeReasoningMiddleware > should map xhigh effort for Claude Opus 4.5 wi
 
   expect(result.providerOptions?.anthropic?.thinking).toEqual({
     type: "enabled",
+    budgetTokens: 60800,
   });
   expect(result.providerOptions?.anthropic?.effort).toBe("high");
 });

package/src/models/anthropic/middleware.ts

@@ -16,11 +16,12 @@ const isClaude = (family: "opus" | "sonnet" | "haiku", version: string) => {
     modelId.includes(`claude-${family}-${dashed}`);
 };
 
+const isClaude4 = (modelId: string) => 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: ChatCompletionsReasoningEffort, modelId: string) {
   if (isOpus46(modelId)) {
@@ -60,7 +61,10 @@ function getMaxOutputTokens(modelId: string): number {
   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: LanguageModelMiddleware = {
   specificationVersion: "v3",
   // eslint-disable-next-line require-await
@@ -79,30 +83,30 @@ export const claudeReasoningMiddleware: LanguageModelMiddleware = {
     if (!reasoning.enabled) {
       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)) {
-        target["thinking"] = { type: "enabled" };
-        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(
+        target["thinking"] = { type: "enabled" };
+        if (clampedMaxTokens) {
+          target["thinking"]["budgetTokens"] = clampedMaxTokens;
+        } else {
+          // FUTURE: warn that reasoning.max_tokens was computed
+          target["thinking"]["budgetTokens"] = calculateReasoningBudgetFromEffort(
             reasoning.effort,
             params.maxOutputTokens ?? getMaxOutputTokens(modelId),
             1024,
-          ),
-        };
+          );
+        }
       }
     } else if (clampedMaxTokens) {
       target["thinking"] = {

package/src/providers/bedrock/middleware.test.ts

@@ -2,19 +2,73 @@ import { MockLanguageModelV3 } from "ai/test";
 import { expect, test } from "bun:test";
 
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { bedrockAnthropicReasoningMiddleware } from "./middleware";
+import { bedrockClaudeReasoningMiddleware, bedrockGptReasoningMiddleware } from "./middleware";
 
-test("bedrockAnthropicReasoningMiddleware > matching provider", () => {
+test("bedrock middlewares > matching provider resolves GPT middleware", () => {
+  const middleware = modelMiddlewareMatcher.resolve({
+    kind: "text",
+    modelId: "openai/gpt-oss-20b",
+    providerId: "amazon-bedrock",
+  });
+
+  expect(middleware).toContain(bedrockGptReasoningMiddleware);
+});
+
+test("bedrock middlewares > matching provider resolves Claude middleware", () => {
   const middleware = modelMiddlewareMatcher.resolve({
     kind: "text",
     modelId: "anthropic/claude-opus-4.6",
     providerId: "amazon-bedrock",
   });
 
-  expect(middleware).toContain(bedrockAnthropicReasoningMiddleware);
+  expect(middleware).toContain(bedrockClaudeReasoningMiddleware);
 });
 
-test("bedrockAnthropicReasoningMiddleware > should map thinking/effort into reasoningConfig", async () => {
+test("bedrockGptReasoningMiddleware > should map reasoningEffort into reasoningConfig", async () => {
+  const params = {
+    prompt: [],
+    providerOptions: {
+      bedrock: {
+        reasoningEffort: "high",
+      },
+    },
+  };
+
+  const result = await bedrockGptReasoningMiddleware.transformParams!({
+    type: "generate",
+    params,
+    model: new MockLanguageModelV3({ modelId: "openai/gpt-oss-20b" }),
+  });
+
+  expect(result.providerOptions?.bedrock).toEqual({
+    reasoningConfig: {
+      maxReasoningEffort: "high",
+    },
+  });
+});
+
+test("bedrockGptReasoningMiddleware > should skip non-gpt models", async () => {
+  const params = {
+    prompt: [],
+    providerOptions: {
+      bedrock: {
+        reasoningEffort: "medium",
+      },
+    },
+  };
+
+  const result = await bedrockGptReasoningMiddleware.transformParams!({
+    type: "generate",
+    params,
+    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4.6" }),
+  });
+
+  expect(result.providerOptions?.bedrock).toEqual({
+    reasoningEffort: "medium",
+  });
+});
+
+test("bedrockClaudeReasoningMiddleware > should map thinking/effort into reasoningConfig", async () => {
   const params = {
     prompt: [],
     providerOptions: {
@@ -28,10 +82,10 @@ test("bedrockAnthropicReasoningMiddleware > should map thinking/effort into reas
     },
   };
 
-  const result = await bedrockAnthropicReasoningMiddleware.transformParams!({
+  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
     type: "generate",
     params,
-    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4.6" }),
+    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4-6" }),
   });
 
   expect(result.providerOptions?.bedrock).toEqual({
@@ -43,7 +97,7 @@ test("bedrockAnthropicReasoningMiddleware > should map thinking/effort into reas
   });
 });
 
-test("bedrockAnthropicReasoningMiddleware > should skip non-anthropic models", async () => {
+test("bedrockClaudeReasoningMiddleware > should skip non-claude models", async () => {
   const params = {
     prompt: [],
     providerOptions: {
@@ -57,7 +111,7 @@ test("bedrockAnthropicReasoningMiddleware > should skip non-anthropic models", a
     },
   };
 
-  const result = await bedrockAnthropicReasoningMiddleware.transformParams!({
+  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
     type: "generate",
     params,
     model: new MockLanguageModelV3({ modelId: "openai/gpt-oss-20b" }),
@@ -71,3 +125,59 @@ test("bedrockAnthropicReasoningMiddleware > should skip non-anthropic models", a
     effort: "high",
   });
 });
+
+test("bedrockClaudeReasoningMiddleware > should not set maxReasoningEffort for Claude 3.x", async () => {
+  const params = {
+    prompt: [],
+    providerOptions: {
+      bedrock: {
+        thinking: {
+          type: "enabled",
+          budgetTokens: 4096,
+        },
+        effort: "high",
+      },
+    },
+  };
+
+  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
+    type: "generate",
+    params,
+    model: new MockLanguageModelV3({ modelId: "anthropic/claude-sonnet-3.7" }),
+  });
+
+  expect(result.providerOptions?.bedrock).toEqual({
+    reasoningConfig: {
+      type: "enabled",
+      budgetTokens: 4096,
+    },
+  });
+});
+
+test("bedrockClaudeReasoningMiddleware > should not set maxReasoningEffort for Claude 4.5", async () => {
+  const params = {
+    prompt: [],
+    providerOptions: {
+      bedrock: {
+        thinking: {
+          type: "enabled",
+          budgetTokens: 4096,
+        },
+        effort: "high",
+      },
+    },
+  };
+
+  const result = await bedrockClaudeReasoningMiddleware.transformParams!({
+    type: "generate",
+    params,
+    model: new MockLanguageModelV3({ modelId: "anthropic/claude-opus-4.5" }),
+  });
+
+  expect(result.providerOptions?.bedrock).toEqual({
+    reasoningConfig: {
+      type: "enabled",
+      budgetTokens: 4096,
+    },
+  });
+});

package/src/providers/bedrock/middleware.ts

@@ -2,7 +2,30 @@ import type { LanguageModelMiddleware } from "ai";
 
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
 
-export const bedrockAnthropicReasoningMiddleware: LanguageModelMiddleware = {
+const isClaude46 = (modelId: string) => modelId.includes("-4-6");
+
+export const bedrockGptReasoningMiddleware: LanguageModelMiddleware = {
+  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"] ??= {}) as Record<string, unknown>;
+    target["maxReasoningEffort"] = effort;
+
+    delete bedrock["reasoningEffort"];
+
+    return params;
+  },
+};
+
+export const bedrockClaudeReasoningMiddleware: LanguageModelMiddleware = {
   specificationVersion: "v3",
   // eslint-disable-next-line require-await
   transformParams: async ({ params, model }) => {
@@ -11,13 +34,12 @@ export const bedrockAnthropicReasoningMiddleware: LanguageModelMiddleware = {
     const bedrock = params.providerOptions?.["bedrock"];
     if (!bedrock || typeof bedrock !== "object") return params;
 
-    const bedrockOptions = bedrock as Record<string, unknown>;
-    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"] ??= {}) as Record<string, unknown>;
+    const target = (bedrock["reasoningConfig"] ??= {}) as Record<string, unknown>;
 
     if (thinking && typeof thinking === "object") {
       const thinkingOptions = thinking as Record<string, unknown>;
@@ -29,15 +51,18 @@ export const bedrockAnthropicReasoningMiddleware: LanguageModelMiddleware = {
       }
     }
 
-    if (effort !== undefined) target["maxReasoningEffort"] = effort;
+    // 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/src/telemetry/ai-sdk.ts

@@ -0,0 +1,46 @@
+import type { LogWarningsFunction } from "ai";
+
+import type { TelemetrySignalLevel } from "../types";
+
+import { logger } from "../logger";
+import { addSpanEvent, setSpanAttributes } from "./span";
+
+type GlobalWithAiSdkWarningLogger = typeof globalThis & {
+  AI_SDK_LOG_WARNINGS?: LogWarningsFunction | false;
+};
+
+export const installAiSdkWarningLogger = (genAiSignalLevel?: TelemetrySignalLevel) => {
+  const logWarnings: LogWarningsFunction = ({ 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 as GlobalWithAiSdkWarningLogger).AI_SDK_LOG_WARNINGS = logWarnings;
+};