@hebo-ai/gateway 0.4.2 → 0.5.0

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

@@ -7,7 +7,7 @@ export const ChatCompletionsContentPartImageSchema = z.object({
     type: z.literal("image_url"),
     image_url: z.object({
         url: z.string(),
-        detail: z.union([z.literal("low"), z.literal("high"), z.literal("auto")]).optional(),
+        detail: z.enum(["low", "high", "auto"]).optional(),
     }),
 });
 export const ChatCompletionsContentPartFileSchema = z.object({
@@ -18,6 +18,33 @@ export const ChatCompletionsContentPartFileSchema = z.object({
         filename: z.string().optional(),
     }),
 });
+export const ChatCompletionsContentPartAudioSchema = z.object({
+    type: z.literal("input_audio"),
+    input_audio: z.object({
+        data: z.string(),
+        // only wav and mp3 are official by OpenAI, rest is taken from Gemini support:
+        // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
+        format: z.enum([
+            "x-aac",
+            "flac",
+            "mp3",
+            "m4a",
+            "mpeg",
+            "mpga",
+            "mp4",
+            "ogg",
+            "pcm",
+            "wav",
+            "webm",
+        ]),
+    }),
+});
+export const ChatCompletionsContentPartSchema = z.discriminatedUnion("type", [
+    ChatCompletionsContentPartTextSchema,
+    ChatCompletionsContentPartImageSchema,
+    ChatCompletionsContentPartFileSchema,
+    ChatCompletionsContentPartAudioSchema,
+]);
 export const ChatCompletionsToolCallSchema = z.object({
     type: z.literal("function"),
     id: z.string(),
@@ -25,7 +52,10 @@ export const ChatCompletionsToolCallSchema = z.object({
         arguments: z.string(),
         name: z.string(),
     }),
-    extra_content: z.record(z.string(), z.any()).optional().meta({ extension: true }),
+    extra_content: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional()
+        .meta({ extension: true }),
 });
 export const ChatCompletionsSystemMessageSchema = z.object({
     role: z.literal("system"),
@@ -34,14 +64,7 @@ export const ChatCompletionsSystemMessageSchema = z.object({
 });
 export const ChatCompletionsUserMessageSchema = z.object({
     role: z.literal("user"),
-    content: z.union([
-        z.string(),
-        z.array(z.union([
-            ChatCompletionsContentPartTextSchema,
-            ChatCompletionsContentPartImageSchema,
-            ChatCompletionsContentPartFileSchema,
-        ])),
-    ]),
+    content: z.union([z.string(), z.array(ChatCompletionsContentPartSchema)]),
     name: z.string().optional(),
 });
 export const ChatCompletionsReasoningDetailSchema = z.object({
@@ -56,8 +79,9 @@ export const ChatCompletionsReasoningDetailSchema = z.object({
 });
 export const ChatCompletionsAssistantMessageSchema = z.object({
     role: z.literal("assistant"),
-    // FUTURE: this should support arrays of TextContentPart and RefusalContentPart
-    content: z.union([z.string(), z.null()]).optional(),
+    content: z
+        .union([z.string(), z.null(), z.array(ChatCompletionsContentPartTextSchema)])
+        .optional(),
     name: z.string().optional(),
     // FUTURE: This should also support Custom Tool Calls
     tool_calls: z.array(ChatCompletionsToolCallSchema).optional(),
@@ -67,15 +91,17 @@ export const ChatCompletionsAssistantMessageSchema = z.object({
         .array(ChatCompletionsReasoningDetailSchema)
         .optional()
         .meta({ extension: true }),
-    extra_content: z.record(z.string(), z.any()).optional().meta({ extension: true }),
+    extra_content: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional()
+        .meta({ extension: true }),
 });
 export const ChatCompletionsToolMessageSchema = z.object({
     role: z.literal("tool"),
-    // FUTURE: this should also support arrays of TextContentParts
-    content: z.string(),
+    content: z.union([z.string(), z.array(ChatCompletionsContentPartTextSchema)]),
     tool_call_id: z.string(),
 });
-export const ChatCompletionsMessageSchema = z.union([
+export const ChatCompletionsMessageSchema = z.discriminatedUnion("role", [
     ChatCompletionsSystemMessageSchema,
     ChatCompletionsUserMessageSchema,
     ChatCompletionsAssistantMessageSchema,
@@ -86,14 +112,12 @@ export const ChatCompletionsToolSchema = z.object({
     function: z.object({
         name: z.string(),
         description: z.string().optional(),
-        parameters: z.record(z.string(), z.any()),
+        parameters: z.record(z.string(), z.unknown()),
         // Missing strict parameter
     }),
 });
 export const ChatCompletionsToolChoiceSchema = z.union([
-    z.literal("none"),
-    z.literal("auto"),
-    z.literal("required"),
+    z.enum(["none", "auto", "required", "validated"]),
     // FUTURE: missing AllowedTools and CustomToolChoice
     z.object({
         type: z.literal("function"),
@@ -102,13 +126,14 @@ export const ChatCompletionsToolChoiceSchema = z.union([
         }),
     }),
 ]);
-export const ChatCompletionsReasoningEffortSchema = z.union([
-    z.literal("none"),
-    z.literal("minimal"),
-    z.literal("low"),
-    z.literal("medium"),
-    z.literal("high"),
-    z.literal("xhigh"),
+export const ChatCompletionsReasoningEffortSchema = z.enum([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
 ]);
 export const ChatCompletionsReasoningConfigSchema = z.object({
     enabled: z.optional(z.boolean()),
@@ -116,6 +141,24 @@ export const ChatCompletionsReasoningConfigSchema = z.object({
     max_tokens: z.optional(z.number()),
     exclude: z.optional(z.boolean()),
 });
+export const ChatCompletionsResponseFormatJsonSchema = z.object({
+    // FUTURE: consider support for legacy json_object (if demand)
+    type: z.literal("json_schema"),
+    json_schema: z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        schema: z.record(z.string(), z.unknown()),
+        // FUTURE: consider support for non-strict mode (for providers that support it)
+        strict: z.boolean().optional(),
+    }),
+});
+export const ChatCompletionsResponseFormatTextSchema = z.object({
+    type: z.literal("text"),
+});
+export const ChatCompletionsResponseFormatSchema = z.discriminatedUnion("type", [
+    ChatCompletionsResponseFormatJsonSchema,
+    ChatCompletionsResponseFormatTextSchema,
+]);
 const ChatCompletionsInputsSchema = z.object({
     messages: z.array(ChatCompletionsMessageSchema),
     tools: z
@@ -132,6 +175,7 @@ const ChatCompletionsInputsSchema = z.object({
     seed: z.int().optional(),
     stop: z.union([z.string(), z.array(z.string())]).optional(),
     top_p: z.number().min(0).max(1.0).optional(),
+    response_format: ChatCompletionsResponseFormatSchema.optional(),
     reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
     // Extensions
     reasoning: ChatCompletionsReasoningConfigSchema.optional().meta({ extension: true }),
@@ -141,18 +185,18 @@ export const ChatCompletionsBodySchema = z.looseObject({
     stream: z.boolean().optional(),
     ...ChatCompletionsInputsSchema.shape,
 });
-export const ChatCompletionsFinishReasonSchema = z.union([
-    z.literal("stop"),
-    z.literal("length"),
-    z.literal("content_filter"),
-    z.literal("tool_calls"),
+export const ChatCompletionsFinishReasonSchema = z.enum([
+    "stop",
+    "length",
+    "content_filter",
+    "tool_calls",
 ]);
 export const ChatCompletionsChoiceSchema = z.object({
     index: z.int().nonnegative(),
     message: ChatCompletionsAssistantMessageSchema,
     finish_reason: ChatCompletionsFinishReasonSchema,
     // FUTURE: model this out
-    logprobs: z.any().optional(),
+    logprobs: z.unknown().optional(),
 });
 export const ChatCompletionsUsageSchema = z.object({
     prompt_tokens: z.int().nonnegative().optional(),
@@ -179,7 +223,7 @@ export const ChatCompletionsSchema = z.object({
     choices: z.array(ChatCompletionsChoiceSchema),
     usage: ChatCompletionsUsageSchema.nullable(),
     // Extensions
-    provider_metadata: z.any().optional().meta({ extension: true }),
+    provider_metadata: z.unknown().optional().meta({ extension: true }),
 });
 export const ChatCompletionsToolCallDeltaSchema = ChatCompletionsToolCallSchema.partial().extend({
     index: z.int().nonnegative(),
@@ -192,7 +236,7 @@ export const ChatCompletionsChoiceDeltaSchema = z.object({
     delta: ChatCompletionsAssistantMessageDeltaSchema,
     finish_reason: ChatCompletionsFinishReasonSchema.nullable(),
     // FUTURE: model this out
-    logprobs: z.any().optional(),
+    logprobs: z.unknown().optional(),
 });
 export const ChatCompletionsChunkSchema = z.object({
     id: z.string(),
@@ -202,5 +246,5 @@ export const ChatCompletionsChunkSchema = z.object({
     choices: z.array(ChatCompletionsChoiceDeltaSchema),
     usage: ChatCompletionsUsageSchema.nullable(),
     // Extensions
-    provider_metadata: z.any().optional().meta({ extension: true }),
+    provider_metadata: z.unknown().optional().meta({ extension: true }),
 });

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

@@ -33,6 +33,6 @@ export declare const EmbeddingsSchema: z.ZodObject<{
         prompt_tokens: z.ZodOptional<z.ZodInt>;
         total_tokens: z.ZodOptional<z.ZodInt>;
     }, z.core.$strip>>;
-    provider_metadata: z.ZodOptional<z.ZodAny>;
+    provider_metadata: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type Embeddings = z.infer<typeof EmbeddingsSchema>;

package/dist/endpoints/embeddings/schema.js

@@ -22,5 +22,5 @@ export const EmbeddingsSchema = z.object({
     model: z.string(),
     usage: EmbeddingsUsageSchema.nullable(),
     // Extensions
-    provider_metadata: z.optional(z.any()).meta({ extension: true }),
+    provider_metadata: z.unknown().optional().meta({ extension: true }),
 });

package/dist/errors/gateway.js

@@ -5,6 +5,7 @@ export class GatewayError extends Error {
     constructor(error, status, code, cause) {
         const isError = error instanceof Error;
         super(isError ? error.message : String(error));
+        this.name = "GatewayError";
         this.cause = cause ?? (isError ? error : undefined);
         this.status = status;
         this.code = code ?? STATUS_CODE(status);

package/dist/logger/default.d.ts

@@ -1,5 +1,4 @@
 import type { LogLevel, Logger } from "./index";
-export declare const getDefaultLogLevel: () => LogLevel;
 export declare const createDefaultLogger: (config: {
     level?: LogLevel;
 }) => Logger;

package/dist/logger/default.js

@@ -1,6 +1,5 @@
-import { serializeError } from "serialize-error";
 import { isProduction, isTest } from "../utils/env";
-export const getDefaultLogLevel = () => isTest() ? "silent" : isProduction() ? "info" : "debug";
+const getDefaultLogLevel = () => isTest() ? "silent" : isProduction() ? "info" : "debug";
 const noop = () => { };
 const LEVEL = {
     trace: 5,
@@ -12,6 +11,31 @@ const LEVEL = {
 };
 const LEVELS = Object.keys(LEVEL);
 const isRecord = (value) => typeof value === "object" && value !== null && !(value instanceof Error);
+function serializeError(err, _seen) {
+    if (!(err instanceof Error))
+        return { message: String(err) };
+    const seen = _seen ?? new WeakSet();
+    if (seen.has(err))
+        return { name: err.name, message: err.message, circular: true };
+    seen.add(err);
+    const out = {};
+    for (const k of Object.getOwnPropertyNames(err)) {
+        if (k.startsWith("_"))
+            continue;
+        let val;
+        try {
+            val = err[k];
+        }
+        catch {
+            val = "[Unreadable]";
+        }
+        if (typeof val === "bigint")
+            val = `${val}n`;
+        // FUTURE: check for circular references within val
+        out[String(k)] = val instanceof Error ? serializeError(val, seen) : val;
+    }
+    return out;
+}
 const buildLogObject = (level, args) => {
     if (args.length === 0)
         return {};
@@ -20,11 +44,11 @@ const buildLogObject = (level, args) => {
     let err;
     let msg;
     if (first instanceof Error) {
-        err = first;
+        err = serializeError(first);
     }
     else if (isRecord(first)) {
         if (first["err"] !== undefined) {
-            err = first["err"];
+            err = serializeError(first["err"]);
             delete first["err"];
         }
         obj = first;
@@ -36,13 +60,13 @@ const buildLogObject = (level, args) => {
         msg = String(second);
     }
     if (err && msg === undefined) {
-        msg = err instanceof Error ? err.message : String(err);
+        msg = err["message"];
     }
     return {
         level,
         time: Date.now(),
         ...(msg ? { msg } : {}),
-        ...(err ? { err: err instanceof Error ? serializeError(err) : err } : {}),
+        ...(err ? { err } : {}),
         ...obj,
     };
 };

package/dist/middleware/utils.js

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

package/dist/models/amazon/middleware.js

@@ -24,6 +24,7 @@ function mapNovaEffort(effort) {
             return "medium";
         case "high":
         case "xhigh":
+        case "max":
             return "high";
     }
 }

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

@@ -1,2 +1,4 @@
 import type { LanguageModelMiddleware } from "ai";
+import type { ChatCompletionsReasoningEffort } from "../../endpoints/chat-completions/schema";
+export declare function mapClaudeReasoningEffort(effort: ChatCompletionsReasoningEffort, modelId: string): "low" | "high" | "medium" | "max";
 export declare const claudeReasoningMiddleware: LanguageModelMiddleware;

package/dist/models/anthropic/middleware.js

@@ -1,15 +1,54 @@
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
-const CLAUDE_MAX_OUTPUT_TOKENS = 64000;
-const CLAUDE_OPUS_4_MAX_OUTPUT_TOKENS = 32000;
-function getMaxOutputTokens(modelId) {
-    if (!modelId.includes("opus-4"))
-        return CLAUDE_MAX_OUTPUT_TOKENS;
-    if (modelId.includes("opus-4.5") || modelId.includes("opus-4-5")) {
-        return CLAUDE_MAX_OUTPUT_TOKENS;
+const isClaude = (family, version) => {
+    const dashed = version.replace(".", "-");
+    return (modelId) => modelId.includes(`claude-${family}-${version}`) ||
+        modelId.includes(`claude-${family}-${dashed}`);
+};
+const isOpus46 = isClaude("opus", "4.6");
+const isOpus45 = isClaude("opus", "4.5");
+const isOpus4 = isClaude("opus", "4");
+const isSonnet46 = isClaude("sonnet", "4.6");
+const isSonnet45 = isClaude("sonnet", "4.5");
+export function mapClaudeReasoningEffort(effort, modelId) {
+    if (isOpus46(modelId)) {
+        switch (effort) {
+            case "none":
+            case "minimal":
+            case "low":
+                return "low";
+            case "medium":
+                return "medium";
+            case "high":
+                return "high";
+            case "xhigh":
+            case "max":
+                return "max";
+        }
     }
-    return CLAUDE_OPUS_4_MAX_OUTPUT_TOKENS;
+    switch (effort) {
+        case "none":
+        case "minimal":
+        case "low":
+            return "low";
+        case "medium":
+            return "medium";
+        case "high":
+        case "xhigh":
+        case "max":
+            return "high";
+    }
+}
+function getMaxOutputTokens(modelId) {
+    if (isOpus46(modelId))
+        return 128_000;
+    if (isOpus45(modelId))
+        return 64_000;
+    if (isOpus4(modelId))
+        return 32_000;
+    return 64_000;
 }
+// https://platform.claude.com/docs/en/build-with-claude/effort
 export const claudeReasoningMiddleware = {
     specificationVersion: "v3",
     // eslint-disable-next-line require-await
@@ -21,20 +60,42 @@ export const claudeReasoningMiddleware = {
         if (!reasoning)
             return params;
         const target = (params.providerOptions["anthropic"] ??= {});
+        const modelId = model.modelId;
+        const clampedMaxTokens = reasoning.max_tokens && Math.min(reasoning.max_tokens, getMaxOutputTokens(modelId));
         if (!reasoning.enabled) {
             target["thinking"] = { type: "disabled" };
         }
-        else if (reasoning.max_tokens) {
-            target["thinking"] = {
-                type: "enabled",
-                budgetTokens: Math.min(reasoning.max_tokens, getMaxOutputTokens(model.modelId)),
-            };
-        }
         else if (reasoning.effort) {
-            // FUTURE: warn that reasoning.max_tokens was computed
+            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(reasoning.effort, params.maxOutputTokens ?? getMaxOutputTokens(modelId), 1024),
+                };
+            }
+        }
+        else if (clampedMaxTokens) {
             target["thinking"] = {
                 type: "enabled",
-                budgetTokens: calculateReasoningBudgetFromEffort(reasoning.effort, params.maxOutputTokens ?? getMaxOutputTokens(model.modelId), 1024),
+                budgetTokens: clampedMaxTokens,
             };
         }
         else {

package/dist/models/google/middleware.js

@@ -16,7 +16,22 @@ export const geminiDimensionsMiddleware = {
         return params;
     },
 };
+// https://ai.google.dev/gemini-api/docs/thinking#thinking-levels
 export function mapGeminiReasoningEffort(effort, modelId) {
+    if (modelId.includes("gemini-3.1-pro")) {
+        switch (effort) {
+            case "none":
+            case "minimal":
+            case "low":
+                return "low";
+            case "medium":
+                return "medium";
+            case "high":
+            case "xhigh":
+            case "max":
+                return "high";
+        }
+    }
     if (modelId.includes("gemini-3-pro")) {
         switch (effort) {
             case "none":
@@ -26,6 +41,7 @@ export function mapGeminiReasoningEffort(effort, modelId) {
             case "medium":
             case "high":
             case "xhigh":
+            case "max":
                 return "high";
         }
     }
@@ -40,6 +56,7 @@ export function mapGeminiReasoningEffort(effort, modelId) {
                 return "medium";
             case "high":
             case "xhigh":
+            case "max":
                 return "high";
         }
     }