@hebo-ai/gateway 0.6.2-rc1 → 0.6.2

package/README.md

@@ -536,14 +536,14 @@ Normalization rules:
 
 - `enabled` -> fall-back to model default if none provided
 - `max_tokens`: fall-back to model default if model supports
-- `effort` supports: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`
+- `effort` supports: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`
 - Generic `effort` -> budget = percentage of `max_tokens`
   - `none`: 0%
   - `minimal`: 10%
   - `low`: 20%
   - `medium`: 50% (default)
   - `high`: 80%
-  - `xhigh` / `max`: 95%
+  - `xhigh`: 95%
 
 Reasoning output is surfaced as extension to the `completion` object.
 
@@ -665,7 +665,7 @@ https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/
 
 > [!TIP]
 > To populate custom span attributes, the inbound W3C `baggage` header is supported. Keys in the `hebo.` namespace are mapped to span attributes, with the namespace stripped. For example: `baggage: hebo.user_id=u-123` becomes span attribute `user_id=u-123`.  
-> For `/chat/completions`, request `metadata` (`Record<string, string>`, key 1-64 chars, value up to 512 chars) is also forwarded to spans as `gen_ai.request.metadata.<key>`.
+> For `/chat/completions` and `/embeddings`, request `metadata` (`Record<string, string>`, key 1-64 chars, value up to 512 chars) is also forwarded to spans as `gen_ai.request.metadata.<key>`.
 
 For observability integration that is not otel compliant, you can disable built-in telemetry and manually instrument requests during `before` / `after` hooks.
 

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

@@ -8,7 +8,12 @@ import { parseDataUrl } from "../../utils/url";
 export function convertToTextCallOptions(params) {
     const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, response_format, reasoning_effort, reasoning, prompt_cache_key, prompt_cache_retention, extra_body, cache_control, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
     Object.assign(rest, parseReasoningOptions(reasoning_effort, reasoning));
-    Object.assign(rest, parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, extra_body?.google?.cached_content, cache_control));
+    Object.assign(rest, parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, cache_control));
+    if (extra_body) {
+        for (const v of Object.values(extra_body)) {
+            Object.assign(rest, v);
+        }
+    }
     const { toolChoice, activeTools } = convertToToolChoiceOptions(tool_choice);
     return {
         messages: convertToModelMessages(messages),
@@ -337,29 +342,25 @@ function parseReasoningOptions(reasoning_effort, reasoning) {
     }
     return out;
 }
-function parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, cached_content, cache_control) {
+function parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, cache_control) {
     const out = {};
-    const syncedCacheKey = prompt_cache_key ?? cached_content;
-    const syncedCachedContent = cached_content ?? prompt_cache_key;
-    let syncedCacheRetention = prompt_cache_retention;
-    if (!syncedCacheRetention && cache_control?.ttl) {
-        syncedCacheRetention = cache_control.ttl === "24h" ? "24h" : "in_memory";
-    }
-    let syncedCacheControl = cache_control;
-    if (!syncedCacheControl && syncedCacheRetention) {
-        syncedCacheControl = {
+    let retention = prompt_cache_retention;
+    if (!retention && cache_control?.ttl) {
+        retention = cache_control.ttl === "24h" ? "24h" : "in_memory";
+    }
+    let control = cache_control;
+    if (!control && retention) {
+        control = {
             type: "ephemeral",
-            ttl: syncedCacheRetention === "24h" ? "24h" : "5m",
+            ttl: retention === "24h" ? "24h" : "5m",
         };
     }
-    if (syncedCacheKey)
-        out["prompt_cache_key"] = syncedCacheKey;
-    if (syncedCacheRetention)
-        out["prompt_cache_retention"] = syncedCacheRetention;
-    if (syncedCachedContent)
-        out["cached_content"] = syncedCachedContent;
-    if (syncedCacheControl)
-        out["cache_control"] = syncedCacheControl;
+    if (prompt_cache_key)
+        out["prompt_cache_key"] = prompt_cache_key;
+    if (retention)
+        out["prompt_cache_retention"] = retention;
+    if (control)
+        out["cache_control"] = control;
     return out;
 }
 // --- Response Flow ---

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

@@ -427,7 +427,6 @@ export declare const ChatCompletionsReasoningEffortSchema: z.ZodEnum<{
     minimal: "minimal";
     medium: "medium";
     xhigh: "xhigh";
-    max: "max";
 }>;
 export type ChatCompletionsReasoningEffort = z.infer<typeof ChatCompletionsReasoningEffortSchema>;
 export declare const ChatCompletionsReasoningConfigSchema: z.ZodObject<{
@@ -439,7 +438,6 @@ export declare const ChatCompletionsReasoningConfigSchema: z.ZodObject<{
         minimal: "minimal";
         medium: "medium";
         xhigh: "xhigh";
-        max: "max";
     }>>;
     max_tokens: z.ZodOptional<z.ZodNumber>;
     exclude: z.ZodOptional<z.ZodBoolean>;
@@ -651,18 +649,12 @@ declare const ChatCompletionsInputsSchema: z.ZodObject<{
         minimal: "minimal";
         medium: "medium";
         xhigh: "xhigh";
-        max: "max";
     }>>;
     prompt_cache_key: z.ZodOptional<z.ZodString>;
     prompt_cache_retention: z.ZodOptional<z.ZodEnum<{
         in_memory: "in_memory";
         "24h": "24h";
     }>>;
-    extra_body: z.ZodOptional<z.ZodObject<{
-        google: z.ZodOptional<z.ZodObject<{
-            cached_content: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
     cache_control: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"ephemeral">;
         ttl: z.ZodOptional<z.ZodString>;
@@ -676,11 +668,11 @@ declare const ChatCompletionsInputsSchema: z.ZodObject<{
             minimal: "minimal";
             medium: "medium";
             xhigh: "xhigh";
-            max: "max";
         }>>;
         max_tokens: z.ZodOptional<z.ZodNumber>;
         exclude: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    extra_body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
 export type ChatCompletionsInputs = z.infer<typeof ChatCompletionsInputsSchema>;
 export declare const ChatCompletionsBodySchema: z.ZodObject<{
@@ -863,18 +855,12 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
         minimal: "minimal";
         medium: "medium";
         xhigh: "xhigh";
-        max: "max";
     }>>;
     prompt_cache_key: z.ZodOptional<z.ZodString>;
     prompt_cache_retention: z.ZodOptional<z.ZodEnum<{
         in_memory: "in_memory";
         "24h": "24h";
     }>>;
-    extra_body: z.ZodOptional<z.ZodObject<{
-        google: z.ZodOptional<z.ZodObject<{
-            cached_content: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
     cache_control: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"ephemeral">;
         ttl: z.ZodOptional<z.ZodString>;
@@ -888,11 +874,11 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
             minimal: "minimal";
             medium: "medium";
             xhigh: "xhigh";
-            max: "max";
         }>>;
         max_tokens: z.ZodOptional<z.ZodNumber>;
         exclude: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    extra_body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     model: z.ZodString;
     stream: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
@@ -1029,7 +1015,7 @@ export declare const ChatCompletionsSchema: z.ZodObject<{
             cache_write_tokens: z.ZodOptional<z.ZodInt>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
-    provider_metadata: z.ZodOptional<z.ZodUnknown>;
+    provider_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
 export type ChatCompletions = z.infer<typeof ChatCompletionsSchema>;
 export declare const ChatCompletionsToolCallDeltaSchema: z.ZodObject<{
@@ -1196,7 +1182,7 @@ export declare const ChatCompletionsChunkSchema: z.ZodObject<{
             cache_write_tokens: z.ZodOptional<z.ZodInt>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
-    provider_metadata: z.ZodOptional<z.ZodUnknown>;
+    provider_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
 export type ChatCompletionsChunk = z.infer<typeof ChatCompletionsChunkSchema>;
 export {};

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

@@ -161,14 +161,11 @@ export const ChatCompletionsToolChoiceSchema = z.union([
 ]);
 export const ChatCompletionsReasoningEffortSchema = z.enum([
     "none",
-    // Extension origin: Gemini
     "minimal",
     "low",
     "medium",
     "high",
     "xhigh",
-    // Extension origin: Anthropic
-    "max",
 ]);
 export const ChatCompletionsReasoningConfigSchema = z.object({
     enabled: z.optional(z.boolean()),
@@ -212,22 +209,16 @@ const ChatCompletionsInputsSchema = z.object({
     reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
     prompt_cache_key: z.string().optional(),
     prompt_cache_retention: z.enum(["in_memory", "24h"]).optional(),
-    // Extension origin: Gemini explicit cache handle
-    // FUTURE: generalize extra_body handling
-    // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/migrate/openai/overview
-    extra_body: z
-        .object({
-        google: z
-            .object({
-            cached_content: z.string().optional().meta({ extension: true }),
-        })
-            .optional(),
-    })
-        .optional(),
     // Extension origin: OpenRouter/Vercel/Anthropic
     cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
     // Extension origin: OpenRouter
     reasoning: ChatCompletionsReasoningConfigSchema.optional().meta({ extension: true }),
+    // Extension origin: Gemini extra_body
+    // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/migrate/openai/overview#extra_body
+    extra_body: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional()
+        .meta({ extension: true }),
 });
 export const ChatCompletionsBodySchema = z.looseObject({
     model: z.string(),
@@ -274,7 +265,10 @@ export const ChatCompletionsSchema = z.object({
     choices: z.array(ChatCompletionsChoiceSchema),
     usage: ChatCompletionsUsageSchema.nullable(),
     // Extension origin: Vercel AI Gateway
-    provider_metadata: z.unknown().optional().meta({ extension: true }),
+    provider_metadata: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional()
+        .meta({ extension: true }),
 });
 export const ChatCompletionsToolCallDeltaSchema = ChatCompletionsToolCallSchema.partial().extend({
     index: z.int().nonnegative(),
@@ -297,5 +291,8 @@ export const ChatCompletionsChunkSchema = z.object({
     choices: z.array(ChatCompletionsChoiceDeltaSchema),
     usage: ChatCompletionsUsageSchema.nullable(),
     // Extension origin: Vercel AI Gateway
-    provider_metadata: z.unknown().optional().meta({ extension: true }),
+    provider_metadata: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional()
+        .meta({ extension: true }),
 });

package/dist/endpoints/embeddings/otel.js

@@ -7,6 +7,11 @@ export const getEmbeddingsRequestAttributes = (inputs, signalLevel) => {
         Object.assign(attrs, {
             "gen_ai.embeddings.dimension.count": inputs.dimensions,
         });
+        if (inputs.metadata) {
+            for (const key in inputs.metadata) {
+                attrs[`gen_ai.request.metadata.${key}`] = inputs.metadata[key];
+            }
+        }
     }
     return attrs;
 };

package/dist/endpoints/embeddings/schema.d.ts

@@ -1,12 +1,18 @@
 import * as z from "zod";
+export declare const EmbeddingsDimensionsSchema: z.ZodInt;
+export type EmbeddingsDimensions = z.infer<typeof EmbeddingsDimensionsSchema>;
+export declare const EmbeddingsMetadataSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type EmbeddingsMetadata = z.infer<typeof EmbeddingsMetadataSchema>;
 export declare const EmbeddingsInputsSchema: z.ZodObject<{
     input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     dimensions: z.ZodOptional<z.ZodInt>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type EmbeddingsInputs = z.infer<typeof EmbeddingsInputsSchema>;
 export declare const EmbeddingsBodySchema: z.ZodObject<{
     input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     dimensions: z.ZodOptional<z.ZodInt>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     model: z.ZodString;
 }, z.core.$loose>;
 export type EmbeddingsBody = z.infer<typeof EmbeddingsBodySchema>;

package/dist/endpoints/embeddings/schema.js

@@ -1,7 +1,10 @@
 import * as z from "zod";
+export const EmbeddingsDimensionsSchema = z.int().nonnegative().max(65536);
+export const EmbeddingsMetadataSchema = z.record(z.string().min(1).max(64), z.string().max(512));
 export const EmbeddingsInputsSchema = z.object({
     input: z.union([z.string(), z.array(z.string())]),
-    dimensions: z.int().nonnegative().max(65536).optional(),
+    dimensions: EmbeddingsDimensionsSchema.optional(),
+    metadata: EmbeddingsMetadataSchema.optional(),
 });
 export const EmbeddingsBodySchema = z.looseObject({
     model: z.string(),

package/dist/middleware/utils.js

@@ -17,7 +17,6 @@ export function calculateReasoningBudgetFromEffort(effort, maxTokens, minTokens
             percentage = 0.8;
             break;
         case "xhigh":
-        case "max":
             percentage = 0.95;
             break;
     }

package/dist/models/amazon/middleware.js

@@ -10,7 +10,9 @@ export const novaDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["nova"] ??= {})["embeddingDimension"] = dimensions;
+        const target = (params.providerOptions["nova"] ??= {});
+        // @ts-expect-error AI SDK does the value checking for us
+        target.embeddingDimension = dimensions;
         delete unknown["dimensions"];
         return params;
     },
@@ -26,7 +28,6 @@ function mapNovaEffort(effort) {
             return "medium";
         case "high":
         case "xhigh":
-        case "max":
             return "high";
     }
 }
@@ -42,18 +43,18 @@ export const novaReasoningMiddleware = {
             return params;
         const target = (params.providerOptions["amazon"] ??= {});
         if (!reasoning.enabled) {
-            target["reasoningConfig"] = { type: "disabled" };
+            target.reasoningConfig = { type: "disabled" };
         }
         else if (reasoning.effort) {
             // FUTURE: warn if mapNovaEffort modified the effort
-            target["reasoningConfig"] = {
+            target.reasoningConfig = {
                 type: "enabled",
                 maxReasoningEffort: mapNovaEffort(reasoning.effort),
             };
         }
         else {
             // FUTURE: warn if reasoning.max_tokens (unsupported) was ignored
-            target["reasoningConfig"] = { type: "enabled" };
+            target.reasoningConfig = { type: "enabled" };
         }
         delete unknown["reasoning"];
         return params;

package/dist/models/anthropic/middleware.js

@@ -22,7 +22,6 @@ export function mapClaudeReasoningEffort(effort, modelId) {
             case "high":
                 return "high";
             case "xhigh":
-            case "max":
                 return "max";
         }
     }
@@ -35,7 +34,6 @@ export function mapClaudeReasoningEffort(effort, modelId) {
             return "medium";
         case "high":
         case "xhigh":
-        case "max":
             return "high";
     }
 }
@@ -66,41 +64,42 @@ export const claudeReasoningMiddleware = {
         const modelId = model.modelId;
         const clampedMaxTokens = reasoning.max_tokens && Math.min(reasoning.max_tokens, getMaxOutputTokens(modelId));
         if (!reasoning.enabled) {
-            target["thinking"] = { type: "disabled" };
+            target.thinking = { type: "disabled" };
         }
         else if (reasoning.effort) {
             if (isClaude4(modelId)) {
-                target["effort"] = mapClaudeReasoningEffort(reasoning.effort, modelId);
+                target.effort = mapClaudeReasoningEffort(reasoning.effort, modelId);
             }
             if (isOpus46(modelId)) {
-                target["thinking"] = clampedMaxTokens
-                    ? { type: "adaptive", budgetTokens: clampedMaxTokens }
+                target.thinking = clampedMaxTokens
+                    ? // @ts-expect-error AI SDK type missing type:adaptive with budgetToken
+                        { type: "adaptive", budgetTokens: clampedMaxTokens }
                     : { type: "adaptive" };
             }
             else if (isSonnet46(modelId)) {
-                target["thinking"] = clampedMaxTokens
+                target.thinking = clampedMaxTokens
                     ? { type: "enabled", budgetTokens: clampedMaxTokens }
                     : { type: "adaptive" };
             }
             else {
-                target["thinking"] = { type: "enabled" };
+                target.thinking = { type: "enabled" };
                 if (clampedMaxTokens) {
-                    target["thinking"]["budgetTokens"] = 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);
+                    target.thinking.budgetTokens = calculateReasoningBudgetFromEffort(reasoning.effort, params.maxOutputTokens ?? getMaxOutputTokens(modelId), 1024);
                 }
             }
         }
         else if (clampedMaxTokens) {
-            target["thinking"] = {
+            target.thinking = {
                 type: "enabled",
                 budgetTokens: clampedMaxTokens,
             };
         }
         else {
-            target["thinking"] = { type: "enabled" };
+            target.thinking = { type: "enabled" };
         }
         delete unknown["reasoning"];
         return params;
@@ -116,7 +115,8 @@ export const claudePromptCachingMiddleware = {
             return params;
         const cacheControl = unknown["cache_control"];
         if (cacheControl) {
-            (params.providerOptions["anthropic"] ??= {})["cacheControl"] = cacheControl;
+            (params.providerOptions["anthropic"] ??= {}).cacheControl =
+                cacheControl;
         }
         delete unknown["cache_control"];
         return params;

package/dist/models/cohere/middleware.js

@@ -17,7 +17,9 @@ export const cohereDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["cohere"] ??= {})["outputDimension"] = dimensions;
+        const target = (params.providerOptions["cohere"] ??= {});
+        // @ts-expect-error AI SDK does the value checking for us
+        target.outputDimension = dimensions;
         delete unknown["dimensions"];
         return params;
     },
@@ -35,20 +37,20 @@ export const cohereReasoningMiddleware = {
             return params;
         const target = (params.providerOptions["cohere"] ??= {});
         if (!reasoning.enabled) {
-            target["thinking"] = { type: "disabled" };
+            target.thinking = { type: "disabled" };
         }
         else if (reasoning.max_tokens) {
-            target["thinking"] = { type: "enabled", tokenBudget: reasoning.max_tokens };
+            target.thinking = { type: "enabled", tokenBudget: reasoning.max_tokens };
         }
         else if (reasoning.effort) {
             // FUTURE: warn that reasoning.max_tokens was computed
-            target["thinking"] = {
+            target.thinking = {
                 type: "enabled",
                 tokenBudget: calculateReasoningBudgetFromEffort(reasoning.effort, params.maxOutputTokens ?? COHERE_MAX_OUTPUT_TOKENS, 1024),
             };
         }
         else {
-            target["thinking"] = { type: "enabled" };
+            target.thinking = { type: "enabled" };
         }
         delete unknown["reasoning"];
         return params;

package/dist/models/google/middleware.d.ts

@@ -1,7 +1,7 @@
 import type { EmbeddingModelMiddleware, LanguageModelMiddleware } from "ai";
 import type { ChatCompletionsReasoningEffort } from "../../endpoints/chat-completions/schema";
 export declare const geminiDimensionsMiddleware: EmbeddingModelMiddleware;
-export declare function mapGeminiReasoningEffort(effort: ChatCompletionsReasoningEffort, modelId: string): ChatCompletionsReasoningEffort | undefined;
+export declare function mapGeminiReasoningEffort(effort: ChatCompletionsReasoningEffort, modelId: string): "low" | "high" | "minimal" | "medium";
 export declare const GEMINI_DEFAULT_MAX_OUTPUT_TOKENS = 65536;
 export declare const GEMINI_2_5_PRO_MIN_THINKING_BUDGET = 128;
 export declare const geminiReasoningMiddleware: LanguageModelMiddleware;

package/dist/models/google/middleware.js

@@ -11,14 +11,15 @@ export const geminiDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["google"] ??= {})["outputDimensionality"] = dimensions;
+        const target = (params.providerOptions["google"] ??= {});
+        target.outputDimensionality = dimensions;
         delete unknown["dimensions"];
         return params;
     },
 };
 // https://ai.google.dev/gemini-api/docs/thinking#thinking-levels
 export function mapGeminiReasoningEffort(effort, modelId) {
-    if (modelId.includes("gemini-3.1-pro")) {
+    if (modelId.includes("pro")) {
         switch (effort) {
             case "none":
             case "minimal":
@@ -28,26 +29,22 @@ export function mapGeminiReasoningEffort(effort, modelId) {
                 return "medium";
             case "high":
             case "xhigh":
-            case "max":
                 return "high";
         }
     }
-    if (modelId.includes("gemini-3-flash") || modelId.includes("gemini-3.1-flash")) {
-        switch (effort) {
-            case "none":
-            case "minimal":
-                return "minimal";
-            case "low":
-                return "low";
-            case "medium":
-                return "medium";
-            case "high":
-            case "xhigh":
-            case "max":
-                return "high";
-        }
+    // Flash
+    switch (effort) {
+        case "none":
+        case "minimal":
+            return "minimal";
+        case "low":
+            return "low";
+        case "medium":
+            return "medium";
+        case "high":
+        case "xhigh":
+            return "high";
     }
-    return effort;
 }
 export const GEMINI_DEFAULT_MAX_OUTPUT_TOKENS = 65536;
 export const GEMINI_2_5_PRO_MIN_THINKING_BUDGET = 128;
@@ -58,6 +55,9 @@ export const geminiReasoningMiddleware = {
         const unknown = params.providerOptions?.["unknown"];
         if (!unknown)
             return params;
+        // If thinking options exist, just pass through
+        if (unknown["thinking_config"])
+            return params;
         const reasoning = unknown["reasoning"];
         if (!reasoning)
             return params;
@@ -65,19 +65,19 @@ export const geminiReasoningMiddleware = {
         const modelId = model.modelId;
         if (modelId.includes("gemini-2")) {
             const is25Pro = modelId.includes("gemini-2.5-pro");
-            target["thinkingConfig"] = {
+            target.thinkingConfig = {
                 thinkingBudget: reasoning.max_tokens ??
                     calculateReasoningBudgetFromEffort(reasoning.effort ?? "none", params.maxOutputTokens ?? GEMINI_DEFAULT_MAX_OUTPUT_TOKENS, is25Pro ? GEMINI_2_5_PRO_MIN_THINKING_BUDGET : 0),
             };
         }
         else if (modelId.includes("gemini-3") && reasoning.effort) {
-            target["thinkingConfig"] = {
+            target.thinkingConfig = {
                 thinkingLevel: mapGeminiReasoningEffort(reasoning.effort, modelId),
             };
             // FUTURE: warn if model is gemini-3 and max_tokens (unsupported) was ignored
         }
-        (target["thinkingConfig"] ??= {})["includeThoughts"] =
-            reasoning.enabled ? !reasoning.exclude : false;
+        const thinkingConfig = (target.thinkingConfig ??= {});
+        thinkingConfig.includeThoughts = reasoning.enabled ? !reasoning.exclude : false;
         delete unknown["reasoning"];
         return params;
     },
@@ -91,9 +91,13 @@ export const geminiPromptCachingMiddleware = {
         const unknown = params.providerOptions?.["unknown"];
         if (!unknown)
             return params;
-        const cachedContent = unknown["cached_content"];
-        if (cachedContent) {
-            (params.providerOptions["google"] ??= {})["cachedContent"] = cachedContent;
+        // If cached_content options exist, just pass through
+        if (unknown["cached_content"])
+            return params;
+        const promptCacheKey = unknown["prompt_cache_key"];
+        if (promptCacheKey) {
+            (params.providerOptions["google"] ??= {}).cachedContent =
+                promptCacheKey;
         }
         delete unknown["cached_content"];
         return params;

package/dist/models/openai/middleware.js

@@ -10,7 +10,8 @@ export const openAIDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["openai"] ??= {})["dimensions"] = dimensions;
+        const target = (params.providerOptions["openai"] ??= {});
+        target.dimensions = dimensions;
         delete unknown["dimensions"];
         return params;
     },
@@ -27,7 +28,6 @@ function mapGptOssReasoningEffort(effort) {
             return "medium";
         case "high":
         case "xhigh":
-        case "max":
             return "high";
     }
 }
@@ -45,13 +45,13 @@ export const openAIReasoningMiddleware = {
         const isGptOss = model.modelId.includes("gpt-oss");
         if (isGptOss) {
             // FUTURE: warn that unable to disable reasoning for gpt-oss models
-            target["reasoningEffort"] = mapGptOssReasoningEffort(reasoning.effort);
+            target.reasoningEffort = mapGptOssReasoningEffort(reasoning.effort);
         }
         else if (reasoning.enabled === false) {
-            target["reasoningEffort"] = "none";
+            target.reasoningEffort = "none";
         }
         else if (reasoning.effort) {
-            target["reasoningEffort"] = reasoning.effort;
+            target.reasoningEffort = reasoning.effort;
         }
         // FUTURE: warn that reasoning.max_tokens (not supported) was ignored
         delete unknown["reasoning"];
@@ -71,9 +71,9 @@ export const openAIPromptCachingMiddleware = {
         if (key || retention) {
             const target = (params.providerOptions["openai"] ??= {});
             if (key)
-                target["promptCacheKey"] = key;
+                target.promptCacheKey = key;
             if (retention)
-                target["promptCacheRetention"] = retention;
+                target.promptCacheRetention = retention;
         }
         delete unknown["prompt_cache_key"];
         delete unknown["prompt_cache_retention"];

package/dist/models/voyage/middleware.js

@@ -10,7 +10,8 @@ export const voyageDimensionsMiddleware = {
         const dimensions = unknown["dimensions"];
         if (!dimensions)
             return params;
-        (params.providerOptions["voyage"] ??= {})["outputDimension"] = dimensions;
+        const target = (params.providerOptions["voyage"] ??= {});
+        target.outputDimension = dimensions;
         delete unknown["dimensions"];
         return params;
     },

package/dist/providers/bedrock/middleware.js

@@ -7,14 +7,15 @@ export const bedrockGptReasoningMiddleware = {
         if (!model.modelId.includes("gpt"))
             return params;
         const bedrock = params.providerOptions?.["bedrock"];
-        if (!bedrock || typeof bedrock !== "object")
+        if (!bedrock)
             return params;
-        const effort = bedrock["reasoningEffort"];
+        const effort = bedrock.reasoningEffort;
         if (effort === undefined)
             return params;
-        const target = (bedrock["reasoningConfig"] ??= {});
-        target["maxReasoningEffort"] = effort;
-        delete bedrock["reasoningEffort"];
+        const target = (bedrock.reasoningConfig ??= {});
+        // @ts-expect-error AI SDK does accept this
+        target.maxReasoningEffort = effort;
+        delete bedrock.reasoningEffort;
         return params;
     },
 };
@@ -25,28 +26,25 @@ export const bedrockClaudeReasoningMiddleware = {
         if (!model.modelId.includes("claude"))
             return params;
         const bedrock = params.providerOptions?.["bedrock"];
-        if (!bedrock || typeof bedrock !== "object")
+        if (!bedrock)
             return params;
-        const thinking = bedrock["thinking"];
-        const effort = bedrock["effort"];
+        const thinking = bedrock.thinking;
+        const effort = bedrock.effort;
         if (!thinking && effort === undefined)
             return params;
-        const target = (bedrock["reasoningConfig"] ??= {});
+        const target = (bedrock.reasoningConfig ??= {});
         if (thinking && typeof thinking === "object") {
-            const thinkingOptions = thinking;
-            if (thinkingOptions["type"] !== undefined) {
-                target["type"] = thinkingOptions["type"];
-            }
-            if (thinkingOptions["budgetTokens"] !== undefined) {
-                target["budgetTokens"] = thinkingOptions["budgetTokens"];
+            target.type = thinking.type;
+            if ("budgetTokens" in thinking && thinking.budgetTokens !== undefined) {
+                target.budgetTokens = thinking.budgetTokens;
             }
         }
         // FUTURE: bedrock currently does not support "effort" for other 4.x models
         if (effort !== undefined && isClaude46(model.modelId)) {
-            target["maxReasoningEffort"] = effort;
+            target.maxReasoningEffort = effort;
         }
-        delete bedrock["thinking"];
-        delete bedrock["effort"];
+        delete bedrock.thinking;
+        delete bedrock.effort;
         return params;
     },
 };
@@ -79,18 +77,18 @@ export const bedrockPromptCachingMiddleware = {
             delete entryBedrock["cacheControl"];
         };
         for (const message of params.prompt) {
-            processCacheControl(message["providerOptions"]);
-            if (!Array.isArray(message["content"]))
+            processCacheControl(message.providerOptions);
+            if (!Array.isArray(message.content))
                 continue;
-            for (const part of message["content"]) {
-                processCacheControl(part["providerOptions"]);
+            for (const part of message.content) {
+                processCacheControl(part.providerOptions);
             }
             lastCacheableBlock = message;
         }
         const bedrock = params.providerOptions?.["bedrock"];
         const cacheControl = bedrock?.["cacheControl"];
         if (cacheControl && !hasExplicitCacheControl && lastCacheableBlock) {
-            ((lastCacheableBlock["providerOptions"] ??= {})["bedrock"] ??= {})["cachePoint"] =
+            ((lastCacheableBlock.providerOptions ??= {})["bedrock"] ??= {})["cachePoint"] =
                 toBedrockCachePoint(model.modelId, cacheControl);
         }
         delete bedrock?.["cacheControl"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.6.2-rc1",
+  "version": "0.6.2",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
   "keywords": [
     "ai",
@@ -179,6 +179,7 @@
     "@ai-sdk/amazon-bedrock": "^4.0.77",
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/cohere": "^3.0.25",
+    "@ai-sdk/google": "^3.0.43",
     "@ai-sdk/google-vertex": "^4.0.80",
     "@ai-sdk/groq": "^3.0.29",
     "@ai-sdk/openai": "^3.0.41",
@@ -196,6 +197,9 @@
     "@ai-sdk/cohere": {
       "optional": true
     },
+    "@ai-sdk/google": {
+      "optional": true
+    },
     "@ai-sdk/google-vertex": {
       "optional": true
     },