@hebo-ai/gateway 0.11.3 → 0.11.5

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

@@ -5,26 +5,26 @@ export const ChatCompletionsContentPartTextSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
     // Extension origin: Anthropic/OpenRouter/Vercel
-    cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ChatCompletionsCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsContentPartImageSchema = z.object({
     type: z.literal("image_url"),
     image_url: z.object({
         url: z.string(),
-        detail: z.enum(["low", "high", "auto"]).optional(),
+        detail: z.enum(["low", "high", "auto"]).nullish(),
     }),
     // Extension origin: OpenRouter/Vercel/Anthropic
-    cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ChatCompletionsCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsContentPartFileSchema = z.object({
     type: z.literal("file"),
     file: z.object({
         data: z.string(),
         media_type: z.string(),
-        filename: z.string().optional(),
+        filename: z.string().nullish(),
     }),
     // Extension origin: OpenRouter/Vercel/Anthropic
-    cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ChatCompletionsCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsContentPartSchema = z.discriminatedUnion("type", [
     ChatCompletionsContentPartTextSchema,
@@ -40,51 +40,51 @@ export const ChatCompletionsToolCallSchema = z.object({
         name: z.string(),
     }),
     // Extension origin: Gemini
-    extra_content: ChatCompletionsProviderMetadataSchema.optional().meta({ extension: true }),
+    extra_content: ChatCompletionsProviderMetadataSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsSystemMessageSchema = z.object({
     role: z.literal("system"),
     content: z.union([z.string(), z.array(ChatCompletionsContentPartTextSchema)]),
-    name: z.string().optional(),
+    name: z.string().nullish(),
     // Extension origin: OpenRouter/Vercel/Anthropic
-    cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ChatCompletionsCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsUserMessageSchema = z.object({
     role: z.literal("user"),
     content: z.union([z.string(), z.array(ChatCompletionsContentPartSchema)]),
-    name: z.string().optional(),
+    name: z.string().nullish(),
     // Extension origin: OpenRouter/Vercel/Anthropic
-    cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ChatCompletionsCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsReasoningDetailSchema = z.object({
-    id: z.string().optional(),
+    id: z.string().nullish(),
     index: z.int().nonnegative(),
     type: z.string(),
-    text: z.string().optional(),
-    signature: z.string().optional(),
-    data: z.string().optional(),
-    summary: z.string().optional(),
-    format: z.string().optional(),
+    text: z.string().nullish(),
+    signature: z.string().nullish(),
+    data: z.string().nullish(),
+    summary: z.string().nullish(),
+    format: z.string().nullish(),
 });
 export const ChatCompletionsAssistantMessageSchema = z.object({
     role: z.literal("assistant"),
     content: z
         .union([z.string(), z.null(), z.array(ChatCompletionsContentPartTextSchema)])
         .optional(),
-    name: z.string().optional(),
+    name: z.string().nullish(),
     // FUTURE: This should also support Custom Tool Calls
-    tool_calls: z.array(ChatCompletionsToolCallSchema).optional(),
+    tool_calls: z.array(ChatCompletionsToolCallSchema).nullish(),
     // Extension origin: OpenRouter/Vercel
-    reasoning: z.string().optional().meta({ extension: true }),
+    reasoning: z.string().nullish().meta({ extension: true }),
     // Extension origin: OpenRouter/Vercel
     reasoning_details: z
         .array(ChatCompletionsReasoningDetailSchema)
-        .optional()
+        .nullish()
         .meta({ extension: true }),
     // Extension origin: Gemini
-    extra_content: ChatCompletionsProviderMetadataSchema.optional().meta({ extension: true }),
+    extra_content: ChatCompletionsProviderMetadataSchema.nullish().meta({ extension: true }),
     // Extension origin: OpenRouter/Vercel/Anthropic
-    cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
+    cache_control: ChatCompletionsCacheControlSchema.nullish().meta({ extension: true }),
 });
 export const ChatCompletionsToolMessageSchema = z.object({
     role: z.literal("tool"),
@@ -97,7 +97,7 @@ export const ChatCompletionsMessageSchema = z.discriminatedUnion("role", [
     ChatCompletionsAssistantMessageSchema,
     ChatCompletionsToolMessageSchema,
 ]);
-export const ChatCompletionsToolSchema = z.object({
+export const ChatCompletionsFunctionToolSchema = z.object({
     type: z.literal("function"),
     function: z.object({
         name: z.string(),
@@ -107,6 +107,21 @@ export const ChatCompletionsToolSchema = z.object({
     }),
     // FUTURE: cache_control support on tools
 });
+// 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 ChatCompletionsHostedToolSchema = z
+    .looseObject({
+    type: z.string(),
+})
+    .refine((value) => value.type !== "function", {
+    message: 'Function tools must use the function tool schema (type: "function")',
+});
+export const ChatCompletionsToolSchema = z.union([
+    ChatCompletionsFunctionToolSchema,
+    ChatCompletionsHostedToolSchema,
+]);
 const ChatCompletionsNamedFunctionToolChoiceSchema = z.object({
     type: z.literal("function"),
     function: z.object({
@@ -161,7 +176,7 @@ const ChatCompletionsInputsSchema = z.object({
     top_p: z.number().min(0).max(1.0).optional(),
     metadata: ChatCompletionsMetadataSchema.optional(),
     response_format: ChatCompletionsResponseFormatSchema.optional(),
-    reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
+    reasoning_effort: ChatCompletionsReasoningEffortSchema.nullish(),
     service_tier: ChatCompletionsServiceTierSchema.optional(),
     prompt_cache_key: z.string().optional(),
     prompt_cache_retention: z.enum(["in-memory", "24h"]).optional(),
@@ -173,7 +188,7 @@ const ChatCompletionsInputsSchema = z.object({
     // Extension origin: OpenRouter/Vercel/Anthropic
     cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
     // Extension origin: OpenRouter
-    reasoning: ChatCompletionsReasoningConfigSchema.optional().meta({ extension: true }),
+    reasoning: ChatCompletionsReasoningConfigSchema.nullish().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: ChatCompletionsProviderMetadataSchema.optional().meta({ extension: true }),

package/dist/endpoints/conversations/handler.js

@@ -7,6 +7,13 @@ import { addSpanEvent } from "../../telemetry/span";
 import { parseRequestBody } from "../../utils/body";
 import { toConversation, toConversationItem, toConversationDeleted } from "./converters";
 import { ConversationCreateParamsSchema, ConversationItemsAddBodySchema, ConversationUpdateBodySchema, ConversationItemListParamsSchema, ConversationListParamsSchema, } from "./schema";
+// Codex-shaped clients echo absent optional fields back as literal null; the
+// request schema accepts that, but the storage layer uses `id?: string`, so
+// normalize null → undefined at the boundary.
+const toStorageItem = (item) => ({
+    ...item,
+    id: item.id ?? undefined,
+});
 export const conversations = (config) => {
     const parsedConfig = parseConfig(config);
     const storage = parsedConfig.storage;
@@ -52,7 +59,7 @@ export const conversations = (config) => {
         addSpanEvent("hebo.request.parsed");
         const entity = await storage.createConversation({
             metadata: parsed.data.metadata,
-            items: parsed.data.items,
+            items: parsed.data.items?.map(toStorageItem),
         });
         logger.debug(`[conversations] created conversation: ${entity.id}`);
         logger.trace({ requestId: ctx.requestId, entity }, "[storage] createConversation result");
@@ -146,7 +153,7 @@ export const conversations = (config) => {
             throw new GatewayError(z.prettifyError(parsed.error), 400, undefined, parsed.error);
         }
         addSpanEvent("hebo.request.parsed");
-        const entities = await storage.addItems(conversationId, parsed.data.items);
+        const entities = await storage.addItems(conversationId, parsed.data.items.map(toStorageItem));
         if (!entities) {
             throw new GatewayError("Conversation not found", 404);
         }