@hebo-ai/gateway 0.6.2-rc0 → 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),
@@ -192,7 +197,7 @@ export function fromChatCompletionsContent(content) {
                 return fromFilePart(part.file.data, part.file.media_type, part.file.filename, part.cache_control);
             case "input_audio":
                 return fromFilePart(part.input_audio.data, `audio/${part.input_audio.format}`, undefined, part.cache_control);
-            default: {
+            case "text": {
                 const out = {
                     type: "text",
                     text: part.text,
@@ -204,6 +209,8 @@ export function fromChatCompletionsContent(content) {
                 }
                 return out;
             }
+            default:
+                throw new Error(`Unhandled content part type: ${part.type}`);
         }
     });
 }
@@ -305,6 +312,7 @@ function parseToolResult(content) {
 }
 function parseJsonOrText(content) {
     try {
+        // oxlint-disable-next-line no-unsafe-assignment
         return { type: "json", value: JSON.parse(content) };
     }
     catch {
@@ -334,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 ---
@@ -414,6 +418,7 @@ export class ChatCompletionsStream extends TransformStream {
         };
         super({
             transform(part, controller) {
+                // oxlint-disable-next-line switch-exhaustiveness-check
                 switch (part.type) {
                     case "text-delta": {
                         controller.enqueue(createChunk({ role: "assistant", content: part.text }, part.providerMetadata));

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

@@ -23,6 +23,7 @@ export const chatCompletions = (config) => {
         }
         // Parse + validate input.
         try {
+            // oxlint-disable-next-line no-unsafe-assignment
             ctx.body = await ctx.request.json();
         }
         catch {
@@ -66,6 +67,7 @@ export const chatCompletions = (config) => {
         const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
+        // oxlint-disable-next-line no-unsafe-argument
         const textOptions = convertToTextCallOptions(inputs);
         logger.trace({
             requestId: ctx.requestId,

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

@@ -96,7 +96,7 @@ const toMessageParts = (message) => {
         case "system":
             return toTextParts(message.content);
         default:
-            return [];
+            throw new Error(`Unhandled content part type: ${message.role}`);
     }
 };
 export const getChatRequestAttributes = (inputs, signalLevel) => {

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

@@ -23,6 +23,7 @@ export const embeddings = (config) => {
         }
         // Parse + validate input.
         try {
+            // oxlint-disable-next-line no-unsafe-assignment
             ctx.body = await ctx.request.json();
         }
         catch {
@@ -65,6 +66,7 @@ export const embeddings = (config) => {
         const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
+        // oxlint-disable-next-line no-unsafe-argument
         const embedOptions = convertToEmbedCallOptions(inputs);
         logger.trace({ requestId: ctx.requestId, options: embedOptions }, "[embeddings] AI SDK options");
         addSpanEvent("hebo.options.prepared");

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/endpoints/models/converters.js

@@ -12,13 +12,13 @@ export function toModel(id, catalogModel) {
         id,
         object: "model",
         created: createdTimestamp,
-        owned_by: id.split("/")[0] || "system",
+        owned_by: id.split("/")[0] ?? "system",
         architecture: {
-            input_modalities: modalities?.input || [],
+            input_modalities: modalities?.input ?? [],
             modality: modalities?.input &&
                 modalities?.output &&
                 `${modalities.input?.[0]}->${modalities.output?.[0]}`,
-            output_modalities: modalities?.output || [],
+            output_modalities: modalities?.output ?? [],
         },
         endpoints: providers?.map((provider) => ({
             tag: provider,

package/dist/lifecycle.js

@@ -6,7 +6,7 @@ import { getBaggageAttributes } from "./telemetry/baggage";
 import { instrumentFetch } from "./telemetry/fetch";
 import { recordRequestDuration } from "./telemetry/gen-ai";
 import { getRequestAttributes, getResponseAttributes } from "./telemetry/http";
-import { recordV8jsMemory } from "./telemetry/memory";
+import { observeV8jsMemoryMetrics } from "./telemetry/memory";
 import { addSpanEvent, setSpanEventsEnabled, setSpanTracer, startSpan } from "./telemetry/span";
 import { wrapStream } from "./telemetry/stream";
 import { resolveOrCreateRequestId } from "./utils/request";
@@ -17,6 +17,7 @@ export const winterCgHandler = (run, config) => {
         setSpanTracer(parsedConfig.telemetry?.tracer);
         setSpanEventsEnabled(parsedConfig.telemetry?.signals?.hebo);
         instrumentFetch(parsedConfig.telemetry?.signals?.hebo);
+        observeV8jsMemoryMetrics(parsedConfig.telemetry?.signals?.hebo);
     }
     return async (request, state) => {
         const start = performance.now();
@@ -57,7 +58,6 @@ export const winterCgHandler = (run, config) => {
             if (ctx.operation === "chat" || ctx.operation === "embeddings") {
                 recordRequestDuration(performance.now() - start, realStatus, ctx, parsedConfig.telemetry?.signals?.gen_ai);
             }
-            recordV8jsMemory(parsedConfig.telemetry?.signals?.hebo);
             span.finish();
         };
         try {

package/dist/logger/default.js

@@ -37,8 +37,6 @@ function serializeError(err, _seen) {
     return out;
 }
 const buildLogObject = (level, args) => {
-    if (args.length === 0)
-        return {};
     const [first, second] = args;
     let obj;
     let err;
@@ -70,7 +68,9 @@ const buildLogObject = (level, args) => {
         ...obj,
     };
 };
-const makeLogFn = (level, write) => (...args) => write(JSON.stringify(buildLogObject(level, args)));
+const makeLogFn = (level, write) => (...args) => {
+    write(JSON.stringify(buildLogObject(level, args)));
+};
 export const createDefaultLogger = (config) => {
     if (config.level === "silent" || getDefaultLogLevel() === "silent") {
         return { trace: noop, debug: noop, info: noop, warn: noop, error: noop };

package/dist/logger/index.d.ts

@@ -1,8 +1,5 @@
-export type LogFn = {
-    (msg: string): void;
-    (obj: Record<string, unknown>, msg?: string): void;
-    (err: Error, msg?: string): void;
-};
+export type LogArgs = [msg: string] | [obj: Record<string, unknown>, msg?: string] | [err: Error, msg?: string];
+export type LogFn = (...args: LogArgs) => void;
 export type Logger = Record<"trace" | "debug" | "info" | "warn" | "error", LogFn>;
 export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "silent";
 export type LoggerConfig = {

package/dist/middleware/common.js

@@ -1,4 +1,5 @@
 function snakeToCamel(key) {
+    // oxlint-disable-next-line prefer-includes
     if (key.indexOf("_") === -1)
         return key;
     let out = "";

package/dist/middleware/utils.js

@@ -17,11 +17,8 @@ export function calculateReasoningBudgetFromEffort(effort, maxTokens, minTokens
             percentage = 0.8;
             break;
         case "xhigh":
-        case "max":
             percentage = 0.95;
             break;
-        default:
-            return 0;
     }
     return Math.max(minTokens, Math.floor(maxTokens * percentage));
 }

package/dist/models/amazon/middleware.js

@@ -10,13 +10,17 @@ 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;
     },
 };
 function mapNovaEffort(effort) {
     switch (effort) {
+        case "none":
+            return;
         case "minimal":
         case "low":
             return "low";
@@ -24,7 +28,6 @@ function mapNovaEffort(effort) {
             return "medium";
         case "high":
         case "xhigh":
-        case "max":
             return "high";
     }
 }
@@ -40,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/catalog.js

@@ -1,4 +1,8 @@
 export function defineModelCatalog(...inputs) {
     const catalogs = inputs.flat().map((input) => (typeof input === "function" ? input() : input));
-    return Object.assign({}, ...catalogs);
+    const out = {};
+    for (const catalog of catalogs) {
+        Object.assign(out, catalog);
+    }
+    return out;
 }

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;