@hebo-ai/gateway 0.6.2-rc1 → 0.7.0

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

@@ -1,4 +1,5 @@
 import * as z from "zod";
+import type { SseErrorFrame, SseFrame } from "../../utils/stream";
 export declare const ChatCompletionsCacheControlSchema: z.ZodObject<{
     type: z.ZodLiteral<"ephemeral">;
     ttl: z.ZodOptional<z.ZodString>;
@@ -427,7 +428,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 +439,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>;
@@ -471,6 +470,14 @@ export declare const ChatCompletionsResponseFormatSchema: z.ZodDiscriminatedUnio
 export type ChatCompletionsResponseFormat = z.infer<typeof ChatCompletionsResponseFormatSchema>;
 export declare const ChatCompletionsMetadataSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 export type ChatCompletionsMetadata = z.infer<typeof ChatCompletionsMetadataSchema>;
+export declare const ChatCompletionsServiceTierSchema: z.ZodEnum<{
+    auto: "auto";
+    default: "default";
+    flex: "flex";
+    scale: "scale";
+    priority: "priority";
+}>;
+export type ChatCompletionsServiceTier = z.infer<typeof ChatCompletionsServiceTierSchema>;
 declare const ChatCompletionsInputsSchema: z.ZodObject<{
     messages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"system">;
@@ -651,18 +658,19 @@ declare const ChatCompletionsInputsSchema: z.ZodObject<{
         minimal: "minimal";
         medium: "medium";
         xhigh: "xhigh";
-        max: "max";
+    }>>;
+    service_tier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        priority: "priority";
     }>>;
     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 +684,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 +871,19 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
         minimal: "minimal";
         medium: "medium";
         xhigh: "xhigh";
-        max: "max";
+    }>>;
+    service_tier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        priority: "priority";
     }>>;
     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,19 +897,19 @@ 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>;
 export type ChatCompletionsBody = z.infer<typeof ChatCompletionsBodySchema>;
 export declare const ChatCompletionsFinishReasonSchema: z.ZodEnum<{
-    tool_calls: "tool_calls";
     stop: "stop";
     length: "length";
+    tool_calls: "tool_calls";
     content_filter: "content_filter";
 }>;
 export type ChatCompletionsFinishReason = z.infer<typeof ChatCompletionsFinishReasonSchema>;
@@ -944,9 +953,9 @@ export declare const ChatCompletionsChoiceSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     finish_reason: z.ZodEnum<{
-        tool_calls: "tool_calls";
         stop: "stop";
         length: "length";
+        tool_calls: "tool_calls";
         content_filter: "content_filter";
     }>;
     logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1010,9 +1019,9 @@ export declare const ChatCompletionsSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>;
         finish_reason: z.ZodEnum<{
-            tool_calls: "tool_calls";
             stop: "stop";
             length: "length";
+            tool_calls: "tool_calls";
             content_filter: "content_filter";
         }>;
         logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1029,7 +1038,14 @@ 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>;
+    service_tier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        priority: "priority";
+    }>>;
+    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<{
@@ -1123,9 +1139,9 @@ export declare const ChatCompletionsChoiceDeltaSchema: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>;
     finish_reason: z.ZodNullable<z.ZodEnum<{
-        tool_calls: "tool_calls";
         stop: "stop";
         length: "length";
+        tool_calls: "tool_calls";
         content_filter: "content_filter";
     }>>;
     logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1177,9 +1193,9 @@ export declare const ChatCompletionsChunkSchema: z.ZodObject<{
             }, z.core.$strip>>>;
         }, z.core.$strip>;
         finish_reason: z.ZodNullable<z.ZodEnum<{
-            tool_calls: "tool_calls";
             stop: "stop";
             length: "length";
+            tool_calls: "tool_calls";
             content_filter: "content_filter";
         }>>;
         logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1196,7 +1212,15 @@ 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>;
+    service_tier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        priority: "priority";
+    }>>;
+    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 type ChatCompletionsStream = ReadableStream<SseFrame<ChatCompletionsChunk> | SseErrorFrame>;
 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()),
@@ -195,6 +192,13 @@ export const ChatCompletionsResponseFormatSchema = z.discriminatedUnion("type",
     ChatCompletionsResponseFormatTextSchema,
 ]);
 export const ChatCompletionsMetadataSchema = z.record(z.string().min(1).max(64), z.string().max(512));
+export const ChatCompletionsServiceTierSchema = z.enum([
+    "auto",
+    "default",
+    "flex",
+    "scale",
+    "priority",
+]);
 const ChatCompletionsInputsSchema = z.object({
     messages: z.array(ChatCompletionsMessageSchema),
     tools: z.array(ChatCompletionsToolSchema).optional(),
@@ -210,24 +214,19 @@ const ChatCompletionsInputsSchema = z.object({
     metadata: ChatCompletionsMetadataSchema.optional(),
     response_format: ChatCompletionsResponseFormatSchema.optional(),
     reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
+    service_tier: ChatCompletionsServiceTierSchema.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(),
@@ -273,8 +272,12 @@ export const ChatCompletionsSchema = z.object({
     model: z.string(),
     choices: z.array(ChatCompletionsChoiceSchema),
     usage: ChatCompletionsUsageSchema.nullable(),
+    service_tier: ChatCompletionsServiceTierSchema.optional(),
     // 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(),
@@ -296,6 +299,10 @@ export const ChatCompletionsChunkSchema = z.object({
     model: z.string(),
     choices: z.array(ChatCompletionsChoiceDeltaSchema),
     usage: ChatCompletionsUsageSchema.nullable(),
+    service_tier: ChatCompletionsServiceTierSchema.optional(),
     // 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/handler.js

@@ -13,7 +13,7 @@ import { getEmbeddingsRequestAttributes, getEmbeddingsResponseAttributes } from
 import { EmbeddingsBodySchema } from "./schema";
 export const embeddings = (config) => {
     const hooks = config.hooks;
-    const handler = async (ctx) => {
+    const handler = async (ctx, cfg) => {
         const start = performance.now();
         ctx.operation = "embeddings";
         addSpanEvent("hebo.handler.started");
@@ -62,7 +62,7 @@ export const embeddings = (config) => {
         ctx.resolvedProviderId = embeddingModel.provider;
         logger.debug(`[embeddings] using ${embeddingModel.provider} for ${ctx.resolvedModelId}`);
         addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = config.telemetry?.signals?.gen_ai;
+        const genAiSignalLevel = cfg.telemetry?.signals?.gen_ai;
         const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.

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

@@ -1,5 +1,5 @@
 import type { Attributes } from "@opentelemetry/api";
-import type { Embeddings, EmbeddingsInputs } from "./schema";
+import type { Embeddings, EmbeddingsBody } from "./schema";
 import { type TelemetrySignalLevel } from "../../types";
-export declare const getEmbeddingsRequestAttributes: (inputs: EmbeddingsInputs, signalLevel?: TelemetrySignalLevel) => Attributes;
+export declare const getEmbeddingsRequestAttributes: (body: EmbeddingsBody, signalLevel?: TelemetrySignalLevel) => Attributes;
 export declare const getEmbeddingsResponseAttributes: (embeddings: Embeddings, signalLevel?: TelemetrySignalLevel) => Attributes;

package/dist/endpoints/embeddings/otel.js

@@ -1,12 +1,17 @@
 import {} from "../../types";
-export const getEmbeddingsRequestAttributes = (inputs, signalLevel) => {
+export const getEmbeddingsRequestAttributes = (body, signalLevel) => {
     if (!signalLevel || signalLevel === "off")
         return {};
     const attrs = {};
     if (signalLevel !== "required") {
         Object.assign(attrs, {
-            "gen_ai.embeddings.dimension.count": inputs.dimensions,
+            "gen_ai.embeddings.dimension.count": body.dimensions,
         });
+        if (body.metadata) {
+            for (const key in body.metadata) {
+                attrs[`gen_ai.request.metadata.${key}`] = body.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/endpoints/models/handler.js

@@ -2,8 +2,8 @@ import { GatewayError } from "../../errors/gateway";
 import { winterCgHandler } from "../../lifecycle";
 import { toModels, toModel } from "./converters";
 export const models = (config) => {
-    // oxlint-disable-next-line require-await
-    const handler = async (ctx) => {
+    // eslint-disable-next-line require-await
+    const handler = async (ctx, _cfg) => {
         ctx.operation = "models";
         if (!ctx.request || ctx.request.method !== "GET") {
             throw new GatewayError("Method Not Allowed", 405);

package/dist/errors/openai.d.ts

@@ -8,12 +8,7 @@ export declare const OpenAIErrorSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare class OpenAIError {
-    readonly error: {
-        message: string;
-        type: string;
-        code: string | undefined;
-        param: string;
-    };
+    readonly error: z.infer<typeof OpenAIErrorSchema>["error"];
     constructor(message: string, type?: string, code?: string, param?: string);
 }
 export declare function toOpenAIError(error: unknown): OpenAIError;

package/dist/lifecycle.d.ts

@@ -1,2 +1,3 @@
-import type { GatewayConfig, GatewayContext } from "./types";
-export declare const winterCgHandler: (run: (ctx: GatewayContext) => Promise<object | ReadableStream<object>>, config: GatewayConfig) => (request: Request, state?: Record<string, unknown>) => Promise<Response>;
+import type { GatewayConfig, GatewayConfigParsed, GatewayContext } from "./types";
+import type { SseFrame } from "./utils/stream";
+export declare const winterCgHandler: (run: (ctx: GatewayContext, cfg: GatewayConfigParsed) => Promise<object | ReadableStream<SseFrame>>, config: GatewayConfig) => (request: Request, state?: Record<string, unknown>) => Promise<Response>;

package/dist/lifecycle.js

@@ -8,7 +8,6 @@ import { recordRequestDuration } from "./telemetry/gen-ai";
 import { getRequestAttributes, getResponseAttributes } from "./telemetry/http";
 import { observeV8jsMemoryMetrics } from "./telemetry/memory";
 import { addSpanEvent, setSpanEventsEnabled, setSpanTracer, startSpan } from "./telemetry/span";
-import { wrapStream } from "./telemetry/stream";
 import { resolveOrCreateRequestId } from "./utils/request";
 import { prepareResponseInit, toResponse } from "./utils/response";
 export const winterCgHandler = (run, config) => {
@@ -69,11 +68,10 @@ export const winterCgHandler = (run, config) => {
                 }
             }
             if (!ctx.response) {
-                ctx.result = (await span.runWithContext(() => run(ctx)));
-                if (ctx.result instanceof ReadableStream) {
-                    ctx.result = wrapStream(ctx.result, { onDone: finalize });
-                }
-                ctx.response = toResponse(ctx.result, prepareResponseInit(ctx.requestId));
+                ctx.result = (await span.runWithContext(() => run(ctx, parsedConfig)));
+                ctx.response = toResponse(ctx.result, prepareResponseInit(ctx.requestId), {
+                    onDone: finalize,
+                });
             }
             if (parsedConfig.hooks?.onResponse) {
                 const onResponse = await parsedConfig.hooks.onResponse(ctx);

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;