@hebo-ai/gateway 0.8.2 → 0.9.0

package/dist/endpoints/responses/schema.js

@@ -0,0 +1,314 @@
+import * as z from "zod";
+export const ResponsesMetadataSchema = z
+    .record(z.string().min(1).max(64), z.string().max(512))
+    .nullable()
+    .optional();
+export const ResponsesItemStatusSchema = z.enum(["in_progress", "completed", "incomplete"]);
+export const ResponsesImageDetailSchema = z.enum(["low", "high", "auto"]);
+/**
+ * --- Messaging Content & Items ---
+ */
+// Content Parts
+export const ResponsesInputTextSchema = z.object({
+    type: z.literal("input_text"),
+    text: z.string(),
+});
+const ResponsesInputImageURLSchema = z.object({
+    type: z.literal("input_image"),
+    image_url: z.string(),
+    file_id: z.string().optional(),
+    detail: ResponsesImageDetailSchema.optional(),
+});
+const ResponsesInputImageIDSchema = z.object({
+    type: z.literal("input_image"),
+    file_id: z.string(),
+    image_url: z.string().optional(),
+    detail: ResponsesImageDetailSchema.optional(),
+});
+export const ResponsesInputImageSchema = z.union([
+    ResponsesInputImageURLSchema,
+    ResponsesInputImageIDSchema,
+]);
+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(),
+});
+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(),
+});
+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(),
+});
+export const ResponsesInputFileSchema = z.union([
+    ResponsesInputFileDataSchema,
+    ResponsesInputFileIDSchema,
+    ResponsesInputFileURLSchema,
+]);
+export const ResponsesInputContentSchema = z.union([
+    ResponsesInputTextSchema,
+    ResponsesInputImageURLSchema,
+    ResponsesInputImageIDSchema,
+    ResponsesInputFileDataSchema,
+    ResponsesInputFileIDSchema,
+    ResponsesInputFileURLSchema,
+    ResponsesInputAudioSchema,
+]);
+export const ResponsesOutputTextSchema = z.object({
+    type: z.literal("output_text"),
+    text: z.string(),
+    annotations: z.array(z.unknown()).optional(),
+});
+// Message Items
+const ResponsesMessageItemBaseSchema = z.object({
+    type: z.literal("message"),
+    id: z.string().optional(),
+    status: ResponsesItemStatusSchema.optional(),
+    // Extension origin: Gemini
+    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    // Extension origin: Anthropic/OpenRouter/Vercel
+    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+});
+const ResponsesUserMessageSchema = ResponsesMessageItemBaseSchema.extend({
+    role: z.literal("user"),
+    content: z.union([z.string(), z.array(ResponsesInputContentSchema)]),
+});
+const ResponsesAssistantMessageSchema = ResponsesMessageItemBaseSchema.extend({
+    role: z.literal("assistant"),
+    content: z.union([z.string(), z.array(ResponsesOutputTextSchema)]),
+});
+const ResponsesSystemMessageSchema = ResponsesMessageItemBaseSchema.extend({
+    role: z.literal("system"),
+    content: z.union([z.string(), z.array(ResponsesInputContentSchema)]),
+});
+const ResponsesDeveloperMessageSchema = ResponsesMessageItemBaseSchema.extend({
+    role: z.literal("developer"),
+    content: z.union([z.string(), z.array(ResponsesInputContentSchema)]),
+});
+export const ResponsesMessageItemSchema = z.discriminatedUnion("role", [
+    ResponsesUserMessageSchema,
+    ResponsesAssistantMessageSchema,
+    ResponsesSystemMessageSchema,
+    ResponsesDeveloperMessageSchema,
+]);
+/**
+ * --- Function ---
+ */
+export const ResponsesFunctionCallSchema = z.object({
+    type: z.literal("function_call"),
+    id: z.string().optional(),
+    call_id: z.string(),
+    name: z.string(),
+    arguments: z.string(),
+    status: ResponsesItemStatusSchema.optional(),
+    // Extension origin: Gemini
+    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    // Extension origin: Anthropic/OpenRouter/Vercel
+    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+});
+export const ResponsesFunctionCallOutputSchema = z.object({
+    type: z.literal("function_call_output"),
+    id: z.string().optional(),
+    call_id: z.string(),
+    output: z.union([z.string(), z.array(ResponsesInputContentSchema)]),
+    status: ResponsesItemStatusSchema.optional(),
+    // Extension origin: Gemini
+    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    // Extension origin: Anthropic/OpenRouter/Vercel
+    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+});
+/**
+ * --- Reasoning ---
+ */
+export const ResponsesSummaryTextSchema = z.object({
+    type: z.literal("summary_text"),
+    text: z.string(),
+});
+export const ResponsesReasoningTextSchema = z.object({
+    type: z.literal("reasoning_text"),
+    text: z.string(),
+});
+export const ResponsesReasoningItemSchema = z.object({
+    type: z.literal("reasoning"),
+    id: z.string().optional(),
+    summary: z.array(ResponsesSummaryTextSchema),
+    content: z.array(ResponsesReasoningTextSchema).optional(),
+    encrypted_content: z.string().optional(),
+    status: ResponsesItemStatusSchema.optional(),
+    // Extension origin: Gemini
+    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+});
+/**
+ * --- Input Items ---
+ */
+export const ResponsesInputItemSchema = z.discriminatedUnion("type", [
+    ResponsesMessageItemSchema,
+    ResponsesFunctionCallSchema,
+    ResponsesFunctionCallOutputSchema,
+    ResponsesReasoningItemSchema,
+]);
+import { CacheControlSchema as ResponsesCacheControlSchema, ReasoningEffortSchema as ResponsesReasoningEffortSchema, ReasoningConfigSchema as ResponsesReasoningConfigSchema, ServiceTierSchema as ResponsesServiceTierSchema, ProviderMetadataSchema as ResponsesProviderMetadataSchema, ContentPartAudioSchema as ResponsesInputAudioSchema, } from "../shared/schema";
+export { ResponsesCacheControlSchema, ResponsesReasoningEffortSchema, ResponsesReasoningConfigSchema, ResponsesServiceTierSchema, ResponsesProviderMetadataSchema, ResponsesInputAudioSchema, };
+/**
+ * --- Tools ---
+ */
+export const ResponsesToolSchema = z.object({
+    type: z.literal("function"),
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.record(z.string(), z.unknown()),
+    strict: z.boolean().optional(),
+});
+const ResponsesNamedFunctionToolChoiceSchema = z.object({
+    type: z.literal("function"),
+    name: z.string(),
+});
+const ResponsesAllowedFunctionToolChoiceSchema = z.object({
+    type: z.literal("allowed_tools"),
+    allowed_tools: z.object({
+        mode: z.enum(["none", "auto", "required"]),
+        tools: z.array(ResponsesNamedFunctionToolChoiceSchema).nonempty(),
+    }),
+});
+export const ResponsesToolChoiceSchema = z.union([
+    z.enum(["none", "auto", "required", "validated"]),
+    ResponsesNamedFunctionToolChoiceSchema,
+    ResponsesAllowedFunctionToolChoiceSchema,
+]);
+/**
+ * --- Text Output Config ---
+ */
+export const ResponsesTextFormatJsonSchema = z.object({
+    // FUTURE: Consider support for legacy json_object (if demand)
+    type: z.literal("json_schema"),
+    name: z.string(),
+    description: z.string().optional(),
+    schema: z.record(z.string(), z.unknown()),
+    strict: z.boolean().optional(),
+});
+export const ResponsesTextFormatTextSchema = z.object({
+    type: z.literal("text"),
+});
+export const ResponsesTextFormatSchema = z.discriminatedUnion("type", [
+    ResponsesTextFormatJsonSchema,
+    ResponsesTextFormatTextSchema,
+]);
+export const ResponsesTextConfigSchema = z.object({
+    format: ResponsesTextFormatSchema.optional(),
+    // FUTURE: Support verbosity configuration
+    // verbosity: z.enum(["low", "medium", "high"]).optional(),
+});
+/**
+ * --- Request Body ---
+ */
+const ResponsesInputsSchema = z.object({
+    input: z.union([z.string(), z.array(ResponsesInputItemSchema)]),
+    instructions: z.string().optional(),
+    tools: z.array(ResponsesToolSchema).optional(),
+    tool_choice: ResponsesToolChoiceSchema.optional(),
+    max_tool_calls: z.number().int().nonnegative().optional(),
+    text: ResponsesTextConfigSchema.optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    top_p: z.number().min(0).max(1.0).optional(),
+    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(),
+    prompt_cache_key: z.string().optional(),
+    metadata: ResponsesMetadataSchema,
+    service_tier: ResponsesServiceTierSchema.optional(),
+    parallel_tool_calls: z.boolean().optional(),
+    // FUTURE: Open Responses API orchestration configurations
+    // previous_response_id: z.string().optional(),
+    // conversation: z.union([z.string(), z.object({ id: z.string() })]).optional(),
+    // context_management: z.array(z.object({ type: z.literal("compaction"), compact_threshold: z.number().optional() })).optional(),
+    // prompt: z.object({ id: z.string(), variables: z.record(z.any()).optional(), version: z.string().optional() }).optional(),
+    // phase: z.enum(["commentary", "final_answer"]).optional(),
+    // safety_identifier: z.string().optional(),
+    // truncation: z.enum(["auto", "disabled"]).optional(),
+    // store: z.boolean().optional(),
+    // background: z.boolean().optional(),
+    // top_logprobs: z.number().int().optional(),
+    // include: z.array(z.string()).optional(),
+    // stream_options: z.object({ include_obfuscation: z.boolean().optional() }).optional(),
+    // Extension origin: OpenRouter/Vercel/Anthropic
+    cache_control: ResponsesCacheControlSchema.optional().meta({ extension: true }),
+    // Extension origin: OpenRouter
+    reasoning_effort: ResponsesReasoningEffortSchema.optional().meta({ extension: true }),
+    // Extension origin: Gemini extra_body
+    extra_body: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+});
+export const ResponsesBodySchema = z.object({
+    model: z.string(),
+    stream: z.boolean().optional(),
+    ...ResponsesInputsSchema.shape,
+});
+/**
+ * --- Output Items ---
+ */
+export const ResponsesOutputMessageSchema = z.object({
+    type: z.literal("message"),
+    id: z.string(),
+    role: z.literal("assistant"),
+    status: z.enum(["in_progress", "completed", "incomplete"]),
+    content: z.array(ResponsesOutputTextSchema),
+    // Extension origin: Gemini
+    extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+});
+export const ResponsesOutputItemSchema = z.discriminatedUnion("type", [
+    ResponsesOutputMessageSchema,
+    ResponsesFunctionCallSchema,
+    ResponsesReasoningItemSchema,
+]);
+/**
+ * --- Response Usage ---
+ */
+export const ResponsesUsageSchema = z.object({
+    input_tokens: z.number().int().nonnegative(),
+    output_tokens: z.number().int().nonnegative(),
+    total_tokens: z.number().int().nonnegative(),
+    input_tokens_details: z
+        .object({
+        cached_tokens: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+    output_tokens_details: z
+        .object({
+        reasoning_tokens: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+});
+/**
+ * --- Response Object ---
+ */
+export const ResponsesStatusSchema = z.enum(["in_progress", "completed", "failed", "incomplete"]);
+export const ResponsesSchema = z.object({
+    id: z.string(),
+    object: z.literal("response"),
+    status: ResponsesStatusSchema,
+    model: z.string(),
+    output: z.array(ResponsesOutputItemSchema),
+    usage: ResponsesUsageSchema.nullable(),
+    incomplete_details: z
+        .object({
+        reason: z.string(),
+    })
+        .nullable()
+        .optional(),
+    created_at: z.number().int(),
+    completed_at: z.number().int().nullable(),
+    service_tier: ResponsesServiceTierSchema.optional(),
+    metadata: ResponsesMetadataSchema,
+    // Extension origin: Vercel AI Gateway
+    provider_metadata: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+});

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

@@ -0,0 +1,55 @@
+import type { SharedV3ProviderMetadata, SharedV3ProviderOptions } from "@ai-sdk/provider";
+import { type JSONValue, type ToolSet, type ModelMessage, type ToolChoice, type Output, type StopCondition } from "ai";
+import type { ReasoningConfig, ReasoningEffort, CacheControl, ServiceTier } from "./schema";
+export type ToolChoiceOptions = {
+    toolChoice?: ToolChoice<ToolSet>;
+    activeTools?: string[];
+};
+export type TextCallOptions = {
+    messages: ModelMessage[];
+    tools?: ToolSet;
+    toolChoice?: ToolChoice<ToolSet>;
+    activeTools?: string[];
+    output?: Output.Output;
+    temperature?: number;
+    maxOutputTokens?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    seed?: number;
+    topP?: number;
+    stopSequences?: string[];
+    stopWhen?: StopCondition<ToolSet> | Array<StopCondition<ToolSet>>;
+    providerOptions: SharedV3ProviderOptions;
+};
+export declare function parseJsonOrText(content: string): {
+    type: "json";
+    value: JSONValue;
+} | {
+    type: "text";
+    value: string;
+};
+export declare function parseBase64(base64: string): Uint8Array;
+export declare function parseImageInput(url: string): {
+    image: string | URL;
+    mediaType?: string;
+};
+export declare function parseReasoningOptions(reasoning_effort?: ReasoningEffort, reasoning?: ReasoningConfig): {
+    reasoning: ReasoningConfig;
+    reasoning_effort?: ReasoningEffort;
+} | {
+    reasoning: {
+        enabled: boolean;
+    };
+    reasoning_effort: string;
+} | {
+    reasoning?: undefined;
+    reasoning_effort?: undefined;
+};
+export declare function parsePromptCachingOptions(prompt_cache_key?: string, prompt_cache_retention?: "in-memory" | "24h", cache_control?: CacheControl): Record<string, unknown>;
+export declare function resolveResponseServiceTier(providerMetadata?: SharedV3ProviderMetadata): ServiceTier | undefined;
+export declare function normalizeToolName(name: string): string;
+export declare function stripEmptyKeys(obj: unknown): unknown;
+export declare function extractReasoningMetadata(providerMetadata?: SharedV3ProviderMetadata): {
+    redactedData?: string;
+    signature?: string;
+};

package/dist/endpoints/shared/converters.js

@@ -0,0 +1,179 @@
+import {} from "ai";
+import { z } from "zod";
+import { GatewayError } from "../../errors/gateway";
+import { parseDataUrl } from "../../utils/url";
+export function parseJsonOrText(content) {
+    try {
+        return { type: "json", value: JSON.parse(content) };
+    }
+    catch {
+        return { type: "text", value: content };
+    }
+}
+export function parseBase64(base64) {
+    try {
+        return z.util.base64ToUint8Array(base64);
+    }
+    catch (error) {
+        throw new GatewayError("Invalid base64 data", 400, undefined, error);
+    }
+}
+export function parseImageInput(url) {
+    const dataPrefix = "data:";
+    if (url.startsWith(dataPrefix)) {
+        const { mimeType, dataStart } = parseDataUrl(url);
+        if (!mimeType || dataStart <= dataPrefix.length || dataStart >= url.length) {
+            throw new GatewayError("Invalid data URL", 400);
+        }
+        if (!mimeType.startsWith("image/")) {
+            throw new GatewayError(`Unsupported image media type: ${mimeType}`, 400);
+        }
+        return {
+            image: url.slice(dataStart),
+            mediaType: mimeType,
+        };
+    }
+    try {
+        return { image: new URL(url) };
+    }
+    catch (error) {
+        throw new GatewayError("Invalid image URL", 400, undefined, error);
+    }
+}
+export function parseReasoningOptions(reasoning_effort, reasoning) {
+    const effort = reasoning?.effort ?? reasoning_effort;
+    const max_tokens = reasoning?.max_tokens;
+    if (reasoning?.enabled === false || effort === "none") {
+        return { reasoning: { enabled: false }, reasoning_effort: "none" };
+    }
+    if (!reasoning && effort === undefined)
+        return {};
+    const out = { reasoning: {} };
+    if (effort) {
+        out.reasoning.enabled = true;
+        out.reasoning.effort = effort;
+        out.reasoning_effort = effort;
+    }
+    if (max_tokens) {
+        out.reasoning.enabled = true;
+        out.reasoning.max_tokens = max_tokens;
+    }
+    if (out.reasoning.enabled) {
+        out.reasoning.exclude = reasoning?.exclude;
+    }
+    return out;
+}
+export function parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, cache_control) {
+    const out = {};
+    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: retention === "24h" ? "24h" : "5m",
+        };
+    }
+    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;
+}
+export function resolveResponseServiceTier(providerMetadata) {
+    if (!providerMetadata)
+        return;
+    for (const metadata of Object.values(providerMetadata)) {
+        const tier = parseReturnedServiceTier(metadata["service_tier"] ??
+            metadata["usage_metadata"]?.["traffic_type"]);
+        if (tier)
+            return tier;
+    }
+}
+function parseReturnedServiceTier(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const n = value.toLowerCase();
+    switch (n) {
+        case "traffic_type_unspecified":
+        case "auto":
+            return "auto";
+        case "default":
+        case "on_demand":
+        case "on-demand":
+        case "shared":
+            return "default";
+        case "on_demand_flex":
+        case "flex":
+            return "flex";
+        case "on_demand_priority":
+        case "priority":
+        case "performance":
+            return "priority";
+        case "provisioned_throughput":
+        case "scale":
+        case "reserved":
+        case "dedicated":
+        case "provisioned":
+        case "throughput":
+            return "scale";
+        default:
+            return undefined;
+    }
+}
+export function normalizeToolName(name) {
+    let out = "";
+    for (let i = 0; i < name.length; i++) {
+        if (out.length === 128)
+            break;
+        // oxlint-disable-next-line unicorn/prefer-code-point
+        const c = name.charCodeAt(i);
+        if ((c >= 48 && c <= 57) ||
+            (c >= 65 && c <= 90) ||
+            (c >= 97 && c <= 122) ||
+            c === 95 ||
+            c === 45 ||
+            c === 46) {
+            out += name[i];
+        }
+        else {
+            out += "_";
+        }
+    }
+    return out;
+}
+export function stripEmptyKeys(obj) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj))
+        return obj;
+    if ("" in obj) {
+        obj[""] = undefined;
+    }
+    return obj;
+}
+export function extractReasoningMetadata(providerMetadata) {
+    if (!providerMetadata)
+        return {};
+    for (const metadata of Object.values(providerMetadata)) {
+        if (metadata && typeof metadata === "object") {
+            let redactedData;
+            let signature;
+            let found = false;
+            if ("redactedData" in metadata && typeof metadata["redactedData"] === "string") {
+                redactedData = metadata["redactedData"];
+                found = true;
+            }
+            if ("signature" in metadata && typeof metadata["signature"] === "string") {
+                signature = metadata["signature"];
+                found = true;
+            }
+            if (found) {
+                return { redactedData, signature };
+            }
+        }
+    }
+    return {};
+}

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

@@ -0,0 +1,70 @@
+import type { SharedV3ProviderMetadata } from "@ai-sdk/provider";
+import * as z from "zod";
+/**
+ * Shared Open Responses item schemas used by both /conversations and /responses.
+ */
+/**
+ * --- Metadata ---
+ */
+export declare const CacheControlSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ephemeral">;
+    ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CacheControl = z.infer<typeof CacheControlSchema>;
+export declare const ProviderMetadataSchema: z.ZodType<SharedV3ProviderMetadata>;
+export type ProviderMetadata = SharedV3ProviderMetadata;
+export declare const ReasoningEffortSchema: z.ZodEnum<{
+    none: "none";
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+}>;
+export type ReasoningEffort = z.infer<typeof ReasoningEffortSchema>;
+export declare const ReasoningConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+    }>>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    exclude: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ReasoningConfig = z.infer<typeof ReasoningConfigSchema>;
+export declare const ServiceTierSchema: z.ZodEnum<{
+    default: "default";
+    auto: "auto";
+    flex: "flex";
+    scale: "scale";
+    priority: "priority";
+}>;
+export type ServiceTier = z.infer<typeof ServiceTierSchema>;
+export declare const ContentPartAudioSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input_audio">;
+    input_audio: z.ZodObject<{
+        data: z.ZodString;
+        format: z.ZodEnum<{
+            "x-aac": "x-aac";
+            flac: "flac";
+            mp3: "mp3";
+            m4a: "m4a";
+            mpeg: "mpeg";
+            mpga: "mpga";
+            mp4: "mp4";
+            ogg: "ogg";
+            pcm: "pcm";
+            wav: "wav";
+            webm: "webm";
+        }>;
+    }, z.core.$strip>;
+    cache_control: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ContentPartAudio = z.infer<typeof ContentPartAudioSchema>;

package/dist/endpoints/shared/schema.js

@@ -0,0 +1,46 @@
+import * as z from "zod";
+/**
+ * Shared Open Responses item schemas used by both /conversations and /responses.
+ */
+/**
+ * --- Metadata ---
+ */
+// Note: The 16-key limit is not currently validated.
+export const CacheControlSchema = z.object({
+    type: z.literal("ephemeral"),
+    ttl: z.string().optional(),
+});
+export const ProviderMetadataSchema = z.record(z.string(), z.record(z.string(), z.any()));
+export const ReasoningEffortSchema = z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]);
+export const ReasoningConfigSchema = z.object({
+    enabled: z.optional(z.boolean()),
+    effort: z.optional(ReasoningEffortSchema),
+    max_tokens: z.optional(z.number()),
+    exclude: z.optional(z.boolean()),
+});
+export const ServiceTierSchema = z.enum(["auto", "default", "flex", "scale", "priority"]);
+const InputAudioFormatSchema = z.enum([
+    "x-aac",
+    "flac",
+    "mp3",
+    "m4a",
+    "mpeg",
+    "mpga",
+    "mp4",
+    "ogg",
+    "pcm",
+    "wav",
+    "webm",
+]);
+const InputAudioSchema = 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: InputAudioFormatSchema,
+});
+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 }),
+});

package/dist/gateway.d.ts

@@ -6,5 +6,6 @@ export declare function gateway(config: GatewayConfig): {
         readonly "/embeddings": Endpoint;
         readonly "/models": Endpoint;
         readonly "/conversations": Endpoint;
+        readonly "/responses": Endpoint;
     };
 };

package/dist/gateway.js

@@ -3,6 +3,7 @@ import { chatCompletions } from "./endpoints/chat-completions/handler";
 import { conversations } from "./endpoints/conversations/handler";
 import { embeddings } from "./endpoints/embeddings/handler";
 import { models } from "./endpoints/models/handler";
+import { responses } from "./endpoints/responses/handler";
 import { GatewayError } from "./errors/gateway";
 import { winterCgHandler } from "./lifecycle";
 import { logger } from "./logger";
@@ -18,6 +19,7 @@ export function gateway(config) {
         ["/embeddings"]: embeddings(parsedConfig),
         ["/models"]: models(parsedConfig),
         ["/conversations"]: conversations(parsedConfig),
+        ["/responses"]: responses(parsedConfig),
     };
     const routeEntries = Object.entries(routes);
     const handler = (req, state) => {