@hebo-ai/gateway 0.5.0 → 0.5.2

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/handler.ts

@@ -36,7 +36,7 @@ import {
   getChatRequestAttributes,
   getChatResponseAttributes,
 } from "./otel";
-import { ChatCompletionsBodySchema } from "./schema";
+import { ChatCompletionsBodySchema, type ChatCompletionsBody } from "./schema";
 
 export const chatCompletions = (config: GatewayConfig): Endpoint => {
   const hooks = config.hooks;
@@ -57,6 +57,7 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
     } catch {
       throw new GatewayError("Invalid JSON", 400);
     }
+    logger.trace({ requestId: ctx.requestId, body: ctx.body }, "[chat] ChatCompletionsBody");
     addSpanEvent("hebo.request.deserialized");
 
     const parsed = ChatCompletionsBodySchema.safeParse(ctx.body);
@@ -68,7 +69,8 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
     addSpanEvent("hebo.request.parsed");
 
     if (hooks?.before) {
-      ctx.body = (await hooks.before(ctx as BeforeHookContext)) ?? ctx.body;
+      ctx.body =
+        ((await hooks.before(ctx as BeforeHookContext)) as ChatCompletionsBody) ?? ctx.body;
       addSpanEvent("hebo.hooks.before.completed");
     }
 
@@ -110,7 +112,7 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
       "[chat] AI SDK options",
     );
     addSpanEvent("hebo.options.prepared");
-    setSpanAttributes(getChatRequestAttributes(inputs, genAiSignalLevel));
+    setSpanAttributes(getChatRequestAttributes(ctx.body, genAiSignalLevel));
 
     // Build middleware chain (model -> forward params -> provider).
     const languageModelWithMiddleware = wrapLanguageModel({
@@ -138,6 +140,10 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
             res as unknown as GenerateTextResult<ToolSet, Output.Output>,
             ctx.resolvedModelId!,
           );
+          logger.trace(
+            { requestId: ctx.requestId, result: streamResult },
+            "[chat] ChatCompletions",
+          );
           addSpanEvent("hebo.result.transformed");
 
           const genAiResponseAttrs = getChatResponseAttributes(streamResult, genAiSignalLevel);
@@ -180,6 +186,7 @@ export const chatCompletions = (config: GatewayConfig): Endpoint => {
 
     // Transform result.
     ctx.result = toChatCompletions(result, ctx.resolvedModelId);
+    logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] ChatCompletions");
     addSpanEvent("hebo.result.transformed");
 
     const genAiResponseAttrs = getChatResponseAttributes(ctx.result, genAiSignalLevel);

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/endpoints/embeddings/handler.ts

@@ -29,7 +29,7 @@ import {
   getEmbeddingsRequestAttributes,
   getEmbeddingsResponseAttributes,
 } from "./otel";
-import { EmbeddingsBodySchema } from "./schema";
+import { EmbeddingsBodySchema, type EmbeddingsBody } from "./schema";
 
 export const embeddings = (config: GatewayConfig): Endpoint => {
   const hooks = config.hooks;
@@ -50,6 +50,7 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
     } catch {
       throw new GatewayError("Invalid JSON", 400);
     }
+    logger.trace({ requestId: ctx.requestId, result: ctx.body }, "[chat] EmbeddingsBody");
     addSpanEvent("hebo.request.deserialized");
 
     const parsed = EmbeddingsBodySchema.safeParse(ctx.body);
@@ -61,7 +62,7 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
     addSpanEvent("hebo.request.parsed");
 
     if (hooks?.before) {
-      ctx.body = (await hooks.before(ctx as BeforeHookContext)) ?? ctx.body;
+      ctx.body = ((await hooks.before(ctx as BeforeHookContext)) as EmbeddingsBody) ?? ctx.body;
       addSpanEvent("hebo.hooks.before.completed");
     }
 
@@ -100,7 +101,7 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
       "[embeddings] AI SDK options",
     );
     addSpanEvent("hebo.options.prepared");
-    setSpanAttributes(getEmbeddingsRequestAttributes(inputs, genAiSignalLevel));
+    setSpanAttributes(getEmbeddingsRequestAttributes(ctx.body, genAiSignalLevel));
 
     // Build middleware chain (model -> forward params -> provider).
     const embeddingModelWithMiddleware = wrapEmbeddingModel({
@@ -121,6 +122,7 @@ export const embeddings = (config: GatewayConfig): Endpoint => {
 
     // Transform result.
     ctx.result = toEmbeddings(result, ctx.modelId);
+    logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] Embeddings");
     addSpanEvent("hebo.result.transformed");
     const genAiResponseAttrs = getEmbeddingsResponseAttributes(ctx.result, genAiSignalLevel);
     recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);

package/src/middleware/debug.ts

@@ -0,0 +1,37 @@
+import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
+
+import { logger } from "../logger";
+
+export const debugLanguageFinalParamsMiddleware: LanguageModelMiddleware = {
+  specificationVersion: "v3",
+  // eslint-disable-next-line require-await
+  transformParams: async ({ params, model }) => {
+    logger.trace(
+      {
+        kind: "text",
+        modelId: model.modelId,
+        providerId: model.provider,
+        params,
+      },
+      "[middleware] final params",
+    );
+    return params;
+  },
+};
+
+export const debugEmbeddingFinalParamsMiddleware: EmbeddingModelMiddleware = {
+  specificationVersion: "v3",
+  // eslint-disable-next-line require-await
+  transformParams: async ({ params, model }) => {
+    logger.trace(
+      {
+        kind: "embedding",
+        modelId: model.modelId,
+        providerId: model.provider,
+        params,
+      },
+      "[middleware] final params",
+    );
+    return params;
+  },
+};

package/src/middleware/matcher.ts

@@ -6,6 +6,7 @@ import type { ProviderId } from "../providers/types";
 import { logger } from "../logger";
 import { addSpanEvent } from "../telemetry/span";
 import { forwardParamsEmbeddingMiddleware, forwardParamsMiddleware } from "./common";
+import { debugEmbeddingFinalParamsMiddleware, debugLanguageFinalParamsMiddleware } from "./debug";
 
 type MiddlewareEntries = {
   language?: LanguageModelMiddleware[];
@@ -110,6 +111,9 @@ class ModelMiddlewareMatcher {
     if (providerId) {
       out.push(...this.collect(this.provider.match(providerId), kind));
     }
+    out.push(
+      kind === "text" ? debugLanguageFinalParamsMiddleware : debugEmbeddingFinalParamsMiddleware,
+    );
 
     if (this.cache.size >= ModelMiddlewareMatcher.MAX_CACHE) {
       let n = Math.ceil(ModelMiddlewareMatcher.MAX_CACHE * 0.2);

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