@hebo-ai/gateway 0.11.4 → 0.11.6

package/dist/endpoints/responses/schema.js

@@ -16,14 +16,14 @@ export const ResponsesInputTextSchema = z.object({
 const ResponsesInputImageURLSchema = z.object({
     type: z.literal("input_image"),
     image_url: z.string(),
-    file_id: z.string().optional(),
-    detail: ResponsesImageDetailSchema.optional(),
+    file_id: z.string().nullish(),
+    detail: ResponsesImageDetailSchema.nullish(),
 });
 const ResponsesInputImageIDSchema = z.object({
     type: z.literal("input_image"),
     file_id: z.string(),
-    image_url: z.string().optional(),
-    detail: ResponsesImageDetailSchema.optional(),
+    image_url: z.string().nullish(),
+    detail: ResponsesImageDetailSchema.nullish(),
 });
 export const ResponsesInputImageSchema = z.union([
     ResponsesInputImageURLSchema,
@@ -32,23 +32,23 @@ export const ResponsesInputImageSchema = z.union([
 const ResponsesInputFileDataSchema = z.object({
     type: z.literal("input_file"),
     file_data: z.string(),
-    file_id: z.string().optional(),
-    file_url: z.string().optional(),
-    filename: z.string().optional(),
+    file_id: z.string().nullish(),
+    file_url: z.string().nullish(),
+    filename: z.string().nullish(),
 });
 const ResponsesInputFileIDSchema = z.object({
     type: z.literal("input_file"),
     file_id: z.string(),
-    file_data: z.string().optional(),
-    file_url: z.string().optional(),
-    filename: z.string().optional(),
+    file_data: z.string().nullish(),
+    file_url: z.string().nullish(),
+    filename: z.string().nullish(),
 });
 const ResponsesInputFileURLSchema = z.object({
     type: z.literal("input_file"),
     file_url: z.string(),
-    file_data: z.string().optional(),
-    file_id: z.string().optional(),
-    filename: z.string().optional(),
+    file_data: z.string().nullish(),
+    file_id: z.string().nullish(),
+    filename: z.string().nullish(),
 });
 export const ResponsesInputFileSchema = z.union([
     ResponsesInputFileDataSchema,
@@ -67,17 +67,17 @@ export const ResponsesInputContentSchema = z.union([
 export const ResponsesOutputTextSchema = z.object({
     type: z.literal("output_text"),
     text: z.string(),
-    annotations: z.array(z.unknown()).optional(),
+    annotations: z.array(z.unknown()).nullish(),
 });
 // Message Items
 const ResponsesMessageItemBaseSchema = z.object({
     type: z.literal("message"),
-    id: z.string().optional(),
-    status: ResponsesItemStatusSchema.optional(),
+    id: z.string().nullish(),
+    status: ResponsesItemStatusSchema.nullish(),
     // Extension origin: Gemini
-    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    extra_content: ResponsesProviderMetadataSchema.nullish().meta({ extension: true }),
     // Extension origin: Anthropic/OpenRouter/Vercel
-    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ResponsesCacheControlSchema.nullish().meta({ extension: true }),
 });
 const ResponsesUserMessageSchema = ResponsesMessageItemBaseSchema.extend({
     role: z.literal("user"),
@@ -106,26 +106,26 @@ export const ResponsesMessageItemSchema = z.discriminatedUnion("role", [
  */
 export const ResponsesFunctionCallSchema = z.object({
     type: z.literal("function_call"),
-    id: z.string().optional(),
+    id: z.string().nullish(),
     call_id: z.string(),
     name: z.string(),
     arguments: z.string(),
-    status: ResponsesItemStatusSchema.optional(),
+    status: ResponsesItemStatusSchema.nullish(),
     // Extension origin: Gemini
-    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    extra_content: ResponsesProviderMetadataSchema.nullish().meta({ extension: true }),
     // Extension origin: Anthropic/OpenRouter/Vercel
-    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ResponsesCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ResponsesFunctionCallOutputSchema = z.object({
     type: z.literal("function_call_output"),
-    id: z.string().optional(),
+    id: z.string().nullish(),
     call_id: z.string(),
     output: z.union([z.string(), z.array(ResponsesInputContentSchema)]),
-    status: ResponsesItemStatusSchema.optional(),
+    status: ResponsesItemStatusSchema.nullish(),
     // Extension origin: Gemini
-    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    extra_content: ResponsesProviderMetadataSchema.nullish().meta({ extension: true }),
     // Extension origin: Anthropic/OpenRouter/Vercel
-    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ResponsesCacheControlSchema.nullish().meta({ extension: true }),
 });
 /**
  * --- Reasoning ---
@@ -140,15 +140,15 @@ export const ResponsesReasoningTextSchema = z.object({
 });
 export const ResponsesReasoningItemSchema = z.object({
     type: z.literal("reasoning"),
-    id: z.string().optional(),
+    id: z.string().nullish(),
     summary: z.array(ResponsesSummaryTextSchema),
-    content: z.array(ResponsesReasoningTextSchema).optional(),
-    encrypted_content: z.string().optional(),
-    status: ResponsesItemStatusSchema.optional(),
+    content: z.array(ResponsesReasoningTextSchema).nullish(),
+    encrypted_content: z.string().nullish(),
+    status: ResponsesItemStatusSchema.nullish(),
     // Extension origin: Gemini
-    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    extra_content: ResponsesProviderMetadataSchema.nullish().meta({ extension: true }),
     // Extension origin: Anthropic/OpenRouter
-    signature: z.string().optional().meta({ extension: true }),
+    signature: z.string().nullish().meta({ extension: true }),
 });
 /**
  * --- Input Items ---
@@ -164,13 +164,28 @@ export { ResponsesCacheControlSchema, ResponsesReasoningEffortSchema, ResponsesR
 /**
  * --- Tools ---
  */
-export const ResponsesToolSchema = z.object({
+export const ResponsesFunctionToolSchema = z.object({
     type: z.literal("function"),
     name: z.string(),
     description: z.string().optional(),
     parameters: z.record(z.string(), z.unknown()),
     strict: z.boolean().optional(),
 });
+// Hosted/built-in tools (e.g. web_search, file_search, code_interpreter).
+// Accepted at the edge so clients like Codex can send their default payload,
+// but not executed by the gateway — they are dropped before the AI SDK call
+// unless the downstream handler explicitly opts them in.
+export const ResponsesHostedToolSchema = z
+    .looseObject({
+    type: z.string(),
+})
+    .refine((value) => value.type !== "function", {
+    message: 'Function tools must use the function tool schema (type: "function")',
+});
+export const ResponsesToolSchema = z.union([
+    ResponsesFunctionToolSchema,
+    ResponsesHostedToolSchema,
+]);
 const ResponsesNamedFunctionToolChoiceSchema = z.object({
     type: z.literal("function"),
     name: z.string(),
@@ -225,7 +240,7 @@ const ResponsesInputsSchema = z.object({
     frequency_penalty: z.number().min(-2.0).max(2.0).optional(),
     presence_penalty: z.number().min(-2.0).max(2.0).optional(),
     max_output_tokens: z.number().int().nonnegative().optional(),
-    reasoning: ResponsesReasoningConfigSchema.optional(),
+    reasoning: ResponsesReasoningConfigSchema.nullish(),
     prompt_cache_key: z.string().optional(),
     metadata: ResponsesMetadataSchema,
     service_tier: ResponsesServiceTierSchema.optional(),

package/dist/endpoints/shared/converters.d.ts

@@ -33,7 +33,7 @@ export declare function parseImageInput(url: string): {
     image: string | URL;
     mediaType?: string;
 };
-export declare function parseReasoningOptions(reasoning_effort?: ReasoningEffort, reasoning?: ReasoningConfig): {
+export declare function parseReasoningOptions(reasoning_effort?: ReasoningEffort | null, reasoning?: ReasoningConfig | null): {
     reasoning: ReasoningConfig;
     reasoning_effort?: ReasoningEffort;
 } | {

package/dist/endpoints/shared/converters.js

@@ -46,7 +46,7 @@ export function parseReasoningOptions(reasoning_effort, reasoning) {
     if (reasoning?.enabled === false || effort === "none") {
         return { reasoning: { enabled: false, effort: "none" }, reasoning_effort: "none" };
     }
-    if (!reasoning && effort === undefined)
+    if (!reasoning && (effort === undefined || effort === null))
         return {};
     const out = { reasoning: {} };
     if (effort) {

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

@@ -91,13 +91,13 @@ export declare const ContentPartAudioSchema: z.ZodObject<{
             webm: "webm";
         }>;
     }, z.core.$strip>;
-    cache_control: z.ZodOptional<z.ZodObject<{
+    cache_control: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         type: z.ZodLiteral<"ephemeral">;
         ttl: z.ZodOptional<z.ZodEnum<{
             "5m": "5m";
             "1h": "1h";
             "24h": "24h";
         }>>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ContentPartAudio = z.infer<typeof ContentPartAudioSchema>;

package/dist/endpoints/shared/schema.js

@@ -62,5 +62,5 @@ export const ContentPartAudioSchema = z.object({
     type: z.literal("input_audio"),
     input_audio: InputAudioSchema,
     // Extension origin: OpenRouter/Vercel/Anthropic
-    cache_control: CacheControlSchema.optional().meta({ extension: true }),
+    cache_control: CacheControlSchema.nullish().meta({ extension: true }),
 });

package/dist/lifecycle.js

@@ -55,6 +55,8 @@ export const winterCgHandler = (run, config) => {
                     requestId: ctx.requestId,
                     err,
                 });
+                // On error we may not reach the handler's own ctx.otel flush, so flush here.
+                span.setAttributes(ctx.otel);
                 span.recordError(err, true);
             }
             span.setAttributes({ "http.response.status_code_effective": realStatus });

package/dist/models/alibaba/presets.d.ts

@@ -191,6 +191,30 @@ export declare const qwen36MaxPreview: import("../../utils").Preset<"alibaba/qwe
     created: string;
     knowledge: string;
 }>;
+export declare const qwen37Plus: import("../../utils").Preset<"alibaba/qwen3.7-plus", CatalogModel, {
+    modalities: {
+        input: readonly ["text", "image", "file"];
+        output: readonly ["text"];
+    };
+    capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
+    providers: readonly ["alibaba"];
+    name: string;
+    context: number;
+    created: string;
+    knowledge: string;
+}>;
+export declare const qwen37Max: import("../../utils").Preset<"alibaba/qwen3.7-max", CatalogModel, {
+    modalities: {
+        input: readonly ["text"];
+        output: readonly ["text"];
+    };
+    capabilities: ("reasoning" | "temperature" | "tool_call" | "structured_output")[];
+    providers: readonly ["alibaba"];
+    name: string;
+    context: number;
+    created: string;
+    knowledge: string;
+}>;
 export declare const qwen3CoderNext: import("../../utils").Preset<"alibaba/qwen3-coder-next", CatalogModel, {
     modalities: {
         input: readonly ["text", "file"];
@@ -246,9 +270,9 @@ export declare const qwen3Embedding8b: import("../../utils").Preset<"alibaba/qwe
     providers: readonly ["alibaba", "azure", "deepinfra"];
 }>;
 export declare const qwen: {
-    readonly latest: readonly [import("../../utils").Preset<"alibaba/qwen3.6-plus", CatalogModel, {
+    readonly latest: readonly [import("../../utils").Preset<"alibaba/qwen3.7-plus", CatalogModel, {
         modalities: {
-            input: readonly ["text", "image", "video", "file"];
+            input: readonly ["text", "image", "file"];
             output: readonly ["text"];
         };
         capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
@@ -257,34 +281,12 @@ export declare const qwen: {
         context: number;
         created: string;
         knowledge: string;
-    }>, import("../../utils").Preset<"alibaba/qwen3.6-flash", CatalogModel, {
+    }>, import("../../utils").Preset<"alibaba/qwen3.7-max", CatalogModel, {
         modalities: {
-            input: readonly ["text", "image", "video", "file"];
-            output: readonly ["text"];
-        };
-        capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
-        providers: readonly ["alibaba", "azure", "deepinfra"];
-        name: string;
-        context: number;
-        created: string;
-        knowledge: string;
-    }>, import("../../utils").Preset<"alibaba/qwen3.6-27b", CatalogModel, {
-        modalities: {
-            input: readonly ["text", "image", "video", "file"];
-            output: readonly ["text"];
-        };
-        capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
-        providers: readonly ["alibaba"];
-        name: string;
-        context: number;
-        created: string;
-        knowledge: string;
-    }>, import("../../utils").Preset<"alibaba/qwen3.6-max-preview", CatalogModel, {
-        modalities: {
-            input: readonly ["text", "image", "video", "file"];
+            input: readonly ["text"];
             output: readonly ["text"];
         };
-        capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
+        capabilities: ("reasoning" | "temperature" | "tool_call" | "structured_output")[];
         providers: readonly ["alibaba"];
         name: string;
         context: number;
@@ -467,6 +469,28 @@ export declare const qwen: {
         context: number;
         created: string;
         knowledge: string;
+    }> | import("../../utils").Preset<"alibaba/qwen3.7-plus", CatalogModel, {
+        modalities: {
+            input: readonly ["text", "image", "file"];
+            output: readonly ["text"];
+        };
+        capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
+        providers: readonly ["alibaba"];
+        name: string;
+        context: number;
+        created: string;
+        knowledge: string;
+    }> | import("../../utils").Preset<"alibaba/qwen3.7-max", CatalogModel, {
+        modalities: {
+            input: readonly ["text"];
+            output: readonly ["text"];
+        };
+        capabilities: ("reasoning" | "temperature" | "tool_call" | "structured_output")[];
+        providers: readonly ["alibaba"];
+        name: string;
+        context: number;
+        created: string;
+        knowledge: string;
     }> | import("../../utils").Preset<"alibaba/qwen3-coder-next", CatalogModel, {
         modalities: {
             input: readonly ["text", "file"];
@@ -693,6 +717,28 @@ export declare const qwen: {
         context: number;
         created: string;
         knowledge: string;
+    }>, import("../../utils").Preset<"alibaba/qwen3.7-plus", CatalogModel, {
+        modalities: {
+            input: readonly ["text", "image", "file"];
+            output: readonly ["text"];
+        };
+        capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
+        providers: readonly ["alibaba"];
+        name: string;
+        context: number;
+        created: string;
+        knowledge: string;
+    }>, import("../../utils").Preset<"alibaba/qwen3.7-max", CatalogModel, {
+        modalities: {
+            input: readonly ["text"];
+            output: readonly ["text"];
+        };
+        capabilities: ("reasoning" | "temperature" | "tool_call" | "structured_output")[];
+        providers: readonly ["alibaba"];
+        name: string;
+        context: number;
+        created: string;
+        knowledge: string;
     }>];
     readonly embeddings: readonly [import("../../utils").Preset<"alibaba/qwen3-embedding-0.6b", CatalogModel, {
         name: string;
@@ -901,6 +947,29 @@ export declare const qwen: {
         created: string;
         knowledge: string;
     }>];
+    readonly "v3.7": readonly [import("../../utils").Preset<"alibaba/qwen3.7-plus", CatalogModel, {
+        modalities: {
+            input: readonly ["text", "image", "file"];
+            output: readonly ["text"];
+        };
+        capabilities: ("reasoning" | "temperature" | "attachments" | "tool_call" | "structured_output")[];
+        providers: readonly ["alibaba"];
+        name: string;
+        context: number;
+        created: string;
+        knowledge: string;
+    }>, import("../../utils").Preset<"alibaba/qwen3.7-max", CatalogModel, {
+        modalities: {
+            input: readonly ["text"];
+            output: readonly ["text"];
+        };
+        capabilities: ("reasoning" | "temperature" | "tool_call" | "structured_output")[];
+        providers: readonly ["alibaba"];
+        name: string;
+        context: number;
+        created: string;
+        knowledge: string;
+    }>];
     readonly coder: readonly [import("../../utils").Preset<"alibaba/qwen3-coder-next", CatalogModel, {
         modalities: {
             input: readonly ["text", "file"];

package/dist/models/alibaba/presets.js

@@ -202,6 +202,30 @@ export const qwen36MaxPreview = presetFor()("alibaba/qwen3.6-max-preview", {
     created: "2026-04-21",
     knowledge: "2025-04",
 });
+export const qwen37Plus = presetFor()("alibaba/qwen3.7-plus", {
+    modalities: {
+        input: ["text", "image", "file"],
+        output: ["text"],
+    },
+    capabilities: ["attachments", "reasoning", "tool_call", "structured_output", "temperature"],
+    providers: ["alibaba"],
+    name: "Qwen3.7 Plus",
+    context: 1_000_000,
+    created: "2026-06-02",
+    knowledge: "2025-04",
+});
+export const qwen37Max = presetFor()("alibaba/qwen3.7-max", {
+    modalities: {
+        input: ["text"],
+        output: ["text"],
+    },
+    capabilities: ["reasoning", "tool_call", "structured_output", "temperature"],
+    providers: ["alibaba"],
+    name: "Qwen3.7 Max",
+    context: 1_000_000,
+    created: "2026-05-21",
+    knowledge: "2025-04",
+});
 export const qwen3CoderNext = presetFor()("alibaba/qwen3-coder-next", {
     modalities: {
         input: ["text", "file"],
@@ -248,17 +272,18 @@ const qwenAtomic = {
     v3: [qwen3_235b, qwen3_32b],
     "v3.5": [qwen35Plus, qwen35Flash, qwen35_397b, qwen35_122b, qwen35_35b, qwen35_27b, qwen35_9b, qwen35_4b, qwen35_2b, qwen35_08b],
     "v3.6": [qwen36Plus, qwen36Flash, qwen36_27b, qwen36MaxPreview],
+    "v3.7": [qwen37Plus, qwen37Max],
     coder: [qwen3CoderNext],
     vl: [qwen3Vl235b],
     embedding: [qwen3Embedding06b, qwen3Embedding4b, qwen3Embedding8b],
 };
 const qwenGroups = {
-    "v3.x": [...qwenAtomic["v3"], ...qwenAtomic["v3.5"], ...qwenAtomic["v3.6"]],
+    "v3.x": [...qwenAtomic["v3"], ...qwenAtomic["v3.5"], ...qwenAtomic["v3.6"], ...qwenAtomic["v3.7"]],
     embeddings: [...qwenAtomic["embedding"]],
 };
 export const qwen = {
     ...qwenAtomic,
     ...qwenGroups,
-    latest: [...qwenAtomic["v3.6"]],
+    latest: [...qwenAtomic["v3.7"]],
     all: Object.values(qwenAtomic).flat(),
 };

package/dist/models/anthropic/middleware.js

@@ -6,13 +6,16 @@ const isClaude = (family, version) => {
         modelId.includes(`claude-${family}-${dashed}`);
 };
 const isClaude4 = (modelId) => modelId.includes("claude-") && modelId.includes("-4");
+const isFable5 = (modelId) => modelId.includes("claude-fable-5");
+const isClaude4OrFable = (modelId) => isClaude4(modelId) || isFable5(modelId);
+const isOpus48 = isClaude("opus", "4.8");
 const isOpus47 = isClaude("opus", "4.7");
 const isOpus46 = isClaude("opus", "4.6");
 const isOpus45 = isClaude("opus", "4.5");
 const isOpus4 = isClaude("opus", "4");
 const isSonnet46 = isClaude("sonnet", "4.6");
 export function mapClaudeReasoningEffort(effort, modelId) {
-    if (isOpus47(modelId)) {
+    if (isOpus48(modelId) || isOpus47(modelId) || isFable5(modelId)) {
         switch (effort) {
             case "none":
             case "minimal":
@@ -58,6 +61,10 @@ export function mapClaudeReasoningEffort(effort, modelId) {
     return undefined;
 }
 function getMaxOutputTokens(modelId) {
+    if (isOpus48(modelId))
+        return 128_000;
+    if (isFable5(modelId))
+        return 128_000;
     if (isOpus47(modelId))
         return 128_000;
     if (isOpus46(modelId))
@@ -89,10 +96,10 @@ export const claudeReasoningMiddleware = {
             target.thinking = { type: "disabled" };
         }
         else if (reasoning.effort) {
-            if (isClaude4(modelId)) {
+            if (isClaude4OrFable(modelId)) {
                 target.effort = mapClaudeReasoningEffort(reasoning.effort, modelId);
             }
-            if (isOpus47(modelId)) {
+            if (isOpus48(modelId) || isOpus47(modelId) || isFable5(modelId)) {
                 target.thinking = { type: "adaptive" };
             }
             else if (isOpus46(modelId)) {
@@ -152,6 +159,6 @@ export const claudePromptCachingMiddleware = {
         return params;
     },
 };
-modelMiddlewareMatcher.useForModel(["anthropic/claude-*3*7*", "anthropic/claude-*4*"], {
+modelMiddlewareMatcher.useForModel(["anthropic/claude-*3*7*", "anthropic/claude-*4*", "anthropic/claude-fable-*"], {
     language: [claudeReasoningMiddleware, claudePromptCachingMiddleware],
 });