@hebo-ai/gateway 0.1.2 → 0.2.0

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

@@ -1,24 +1,24 @@
-import * as z from "zod/mini";
-export const CompletionsContentPartTextSchema = z.object({
+import * as z from "zod";
+export const ChatCompletionsContentPartTextSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
 });
-export const CompletionsContentPartImageSchema = z.object({
+export const ChatCompletionsContentPartImageSchema = z.object({
     type: z.literal("image_url"),
     image_url: z.object({
         url: z.string(),
-        detail: z.optional(z.union([z.literal("low"), z.literal("high"), z.literal("auto")])),
+        detail: z.union([z.literal("low"), z.literal("high"), z.literal("auto")]).optional(),
     }),
 });
-export const CompletionsContentPartFileSchema = z.object({
+export const ChatCompletionsContentPartFileSchema = z.object({
     type: z.literal("file"),
     file: z.object({
         data: z.string(),
         media_type: z.string(),
-        filename: z.string(),
+        filename: z.string().optional(),
     }),
 });
-export const CompletionsToolCallSchema = z.object({
+export const ChatCompletionsToolCallSchema = z.object({
     type: z.literal("function"),
     id: z.string(),
     function: z.object({
@@ -26,51 +26,59 @@ export const CompletionsToolCallSchema = z.object({
         name: z.string(),
     }),
 });
-export const CompletionsSystemMessageSchema = z.object({
+export const ChatCompletionsSystemMessageSchema = z.object({
     role: z.literal("system"),
     content: z.string(),
+    name: z.string().optional(),
 });
-export const CompletionsUserMessageSchema = z.object({
+export const ChatCompletionsUserMessageSchema = z.object({
     role: z.literal("user"),
     content: z.union([
         z.string(),
         z.array(z.union([
-            CompletionsContentPartTextSchema,
-            CompletionsContentPartImageSchema,
-            CompletionsContentPartFileSchema,
+            ChatCompletionsContentPartTextSchema,
+            ChatCompletionsContentPartImageSchema,
+            ChatCompletionsContentPartFileSchema,
         ])),
     ]),
+    name: z.string().optional(),
 });
-export const CompletionsAssistantMessageSchema = z.object({
+export const ChatCompletionsAssistantMessageSchema = z.object({
     role: z.literal("assistant"),
-    content: z.union([z.string(), z.null()]),
-    tool_calls: z.optional(z.array(CompletionsToolCallSchema)),
-    reasoning: z.optional(z.string()),
-    reasoning_content: z.optional(z.string()),
+    // FUTURE: this should support arrays of TextContentPart and RefusalContentPart
+    content: z.union([z.string(), z.null()]).optional(),
+    name: z.string().optional(),
+    // FUTURE: This should also support Custom Tool Calls
+    tool_calls: z.array(ChatCompletionsToolCallSchema).optional(),
+    // Extensions
+    reasoning_content: z.string().optional().meta({ extension: true }),
 });
-export const CompletionsToolMessageSchema = z.object({
+export const ChatCompletionsToolMessageSchema = z.object({
     role: z.literal("tool"),
+    // FUTURE: this should also support arrays of TextContentParts
     content: z.string(),
     tool_call_id: z.string(),
 });
-export const CompletionsMessageSchema = z.union([
-    CompletionsSystemMessageSchema,
-    CompletionsUserMessageSchema,
-    CompletionsAssistantMessageSchema,
-    CompletionsToolMessageSchema,
+export const ChatCompletionsMessageSchema = z.union([
+    ChatCompletionsSystemMessageSchema,
+    ChatCompletionsUserMessageSchema,
+    ChatCompletionsAssistantMessageSchema,
+    ChatCompletionsToolMessageSchema,
 ]);
-export const CompletionsToolSchema = z.object({
+export const ChatCompletionsToolSchema = z.object({
     type: z.literal("function"),
     function: z.object({
         name: z.string(),
-        description: z.optional(z.string()),
+        description: z.string().optional(),
         parameters: z.record(z.string(), z.any()),
+        // Missing strict parameter
     }),
 });
-export const CompletionsToolChoiceSchema = z.union([
+export const ChatCompletionsToolChoiceSchema = z.union([
     z.literal("none"),
     z.literal("auto"),
     z.literal("required"),
+    // FUTURE: missing AllowedTools and CustomToolChoice
     z.object({
         type: z.literal("function"),
         function: z.object({
@@ -78,46 +86,105 @@ export const CompletionsToolChoiceSchema = z.union([
         }),
     }),
 ]);
-export const CompletionsInputsSchema = z.object({
-    messages: z.array(CompletionsMessageSchema),
-    tools: z.optional(z.array(CompletionsToolSchema)),
-    tool_choice: z.optional(CompletionsToolChoiceSchema),
-    temperature: z.optional(z.number()),
+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 ChatCompletionsReasoningConfigSchema = z.object({
+    enabled: z.optional(z.boolean()),
+    effort: z.optional(ChatCompletionsReasoningEffortSchema),
+    max_tokens: z.optional(z.number()),
+    exclude: z.optional(z.boolean()),
+});
+const ChatCompletionsInputsSchema = z.object({
+    messages: z.array(ChatCompletionsMessageSchema),
+    tools: z
+        .array(
+    // FUTURE: Missing CustomTool
+    ChatCompletionsToolSchema)
+        .optional(),
+    tool_choice: ChatCompletionsToolChoiceSchema.optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    max_tokens: z.int().nonnegative().optional(),
+    max_completion_tokens: z.int().nonnegative().optional(),
+    frequency_penalty: z.number().min(-2.0).max(2.0).optional(),
+    presence_penalty: z.number().min(-2.0).max(2.0).optional(),
+    seed: z.int().optional(),
+    stop: z.union([z.string(), z.array(z.string())]).optional(),
+    top_p: z.number().min(0).max(1.0).optional(),
+    reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
+    // Extensions
+    reasoning: ChatCompletionsReasoningConfigSchema.optional().meta({ extension: true }),
 });
-export const CompletionsBodySchema = z.extend(CompletionsInputsSchema, {
+export const ChatCompletionsBodySchema = z.looseObject({
     model: z.string(),
-    stream: z.optional(z.boolean()),
+    stream: z.boolean().optional(),
+    ...ChatCompletionsInputsSchema.shape,
 });
-export const CompletionsFinishReasonSchema = z.union([
+export const ChatCompletionsFinishReasonSchema = z.union([
     z.literal("stop"),
     z.literal("length"),
     z.literal("content_filter"),
     z.literal("tool_calls"),
 ]);
-export const CompletionsChoiceSchema = z.object({
-    index: z.number(),
-    message: CompletionsAssistantMessageSchema,
-    finish_reason: CompletionsFinishReasonSchema,
-    logprobs: z.optional(z.any()),
-});
-export const CompletionsUsageSchema = z.object({
-    prompt_tokens: z.number(),
-    completion_tokens: z.number(),
-    total_tokens: z.number(),
-    completion_tokens_details: z.optional(z.object({
-        reasoning_tokens: z.optional(z.number()),
-    })),
-    prompt_tokens_details: z.optional(z.object({
-        cached_tokens: z.optional(z.number()),
-    })),
-});
-export const CompletionsSchema = z.object({
+export const ChatCompletionsChoiceSchema = z.object({
+    index: z.int().nonnegative(),
+    message: ChatCompletionsAssistantMessageSchema,
+    finish_reason: ChatCompletionsFinishReasonSchema,
+    // FUTURE: model this out
+    logprobs: z.any().optional(),
+});
+export const ChatCompletionsUsageSchema = z.object({
+    prompt_tokens: z.int().nonnegative().optional(),
+    completion_tokens: z.int().nonnegative().optional(),
+    total_tokens: z.int().nonnegative().optional(),
+    completion_tokens_details: z
+        .object({
+        // FUTURE: add missing properties
+        reasoning_tokens: z.int().nonnegative().optional(),
+    })
+        .optional(),
+    prompt_tokens_details: z
+        .object({
+        // FUTURE: add missing properties
+        cached_tokens: z.int().nonnegative().optional(),
+    })
+        .optional(),
+});
+export const ChatCompletionsSchema = z.object({
     id: z.string(),
     object: z.literal("chat.completion"),
-    created: z.number(),
+    created: z.int().nonnegative(),
+    model: z.string(),
+    choices: z.array(ChatCompletionsChoiceSchema),
+    usage: ChatCompletionsUsageSchema.nullable(),
+    // Extensions
+    provider_metadata: z.any().optional().meta({ extension: true }),
+});
+export const ChatCompletionsToolCallDeltaSchema = ChatCompletionsToolCallSchema.partial().extend({
+    index: z.int().nonnegative(),
+});
+export const ChatCompletionsAssistantMessageDeltaSchema = ChatCompletionsAssistantMessageSchema.partial().extend({
+    tool_calls: z.array(ChatCompletionsToolCallDeltaSchema).optional(),
+});
+export const ChatCompletionsChoiceDeltaSchema = z.object({
+    index: z.int().nonnegative(),
+    delta: ChatCompletionsAssistantMessageDeltaSchema,
+    finish_reason: ChatCompletionsFinishReasonSchema.nullable(),
+    // FUTURE: model this out
+    logprobs: z.any().optional(),
+});
+export const ChatCompletionsChunkSchema = z.object({
+    id: z.string(),
+    object: z.literal("chat.completion.chunk"),
+    created: z.int().nonnegative(),
     model: z.string(),
-    choices: z.array(CompletionsChoiceSchema),
-    usage: z.optional(CompletionsUsageSchema),
-    system_fingerprint: z.optional(z.string()),
-    providerMetadata: z.optional(z.any()),
+    choices: z.array(ChatCompletionsChoiceDeltaSchema),
+    usage: ChatCompletionsUsageSchema.nullable(),
+    // Extensions
+    provider_metadata: z.any().optional().meta({ extension: true }),
 });

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

@@ -1,10 +1,10 @@
-import type { ProviderOptions } from "@ai-sdk/provider-utils";
+import type { SharedV3ProviderOptions } from "@ai-sdk/provider";
 import type { EmbedManyResult } from "ai";
 import type { EmbeddingsInputs, Embeddings } from "./schema";
 export type EmbedCallOptions = {
     values: string[];
-    providerOptions: ProviderOptions;
+    providerOptions: SharedV3ProviderOptions;
 };
-export declare function transformEmbeddingsInputs(params: EmbeddingsInputs): EmbedCallOptions;
+export declare function convertToEmbedCallOptions(params: EmbeddingsInputs): EmbedCallOptions;
 export declare function toEmbeddings(embedManyResult: EmbedManyResult, modelId: string): Embeddings;
-export declare function createEmbeddingsResponse(embedManyResult: EmbedManyResult, modelId: string): Response;
+export declare function createEmbeddingsResponse(embedManyResult: EmbedManyResult, modelId: string, responseInit?: ResponseInit): Response;

package/dist/endpoints/embeddings/converters.js

@@ -1,9 +1,10 @@
-export function transformEmbeddingsInputs(params) {
+import { mergeResponseInit } from "../../utils/response";
+export function convertToEmbedCallOptions(params) {
     const { input, ...rest } = params;
     return {
         values: Array.isArray(input) ? input : [input],
         providerOptions: {
-            openAICompat: rest,
+            unknown: rest,
         },
     };
 }
@@ -14,19 +15,17 @@ export function toEmbeddings(embedManyResult, modelId) {
         index,
     }));
     const usage = {
-        prompt_tokens: embedManyResult.usage?.tokens || 0,
-        total_tokens: embedManyResult.usage?.tokens || 0,
+        prompt_tokens: embedManyResult.usage.tokens,
+        total_tokens: embedManyResult.usage.tokens,
     };
     return {
         object: "list",
         data,
         model: modelId,
         usage,
-        providerMetadata: embedManyResult.providerMetadata,
+        provider_metadata: embedManyResult.providerMetadata,
     };
 }
-export function createEmbeddingsResponse(embedManyResult, modelId) {
-    return new Response(JSON.stringify(toEmbeddings(embedManyResult, modelId)), {
-        headers: { "Content-Type": "application/json" },
-    });
+export function createEmbeddingsResponse(embedManyResult, modelId, responseInit) {
+    return new Response(JSON.stringify(toEmbeddings(embedManyResult, modelId)), mergeResponseInit({ "Content-Type": "application/json" }, responseInit));
 }

package/dist/endpoints/embeddings/handler.js

@@ -1,20 +1,20 @@
-import { embedMany } from "ai";
+import { embedMany, wrapEmbeddingModel } from "ai";
 import * as z from "zod/mini";
-import { parseConfig } from "../../config";
+import { withLifecycle } from "../../lifecycle";
+import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { resolveProvider } from "../../providers/registry";
 import { createErrorResponse } from "../../utils/errors";
-import { withHooks } from "../../utils/hooks";
-import { transformEmbeddingsInputs, createEmbeddingsResponse } from "./converters";
+import { convertToEmbedCallOptions, createEmbeddingsResponse } from "./converters";
 import { EmbeddingsBodySchema } from "./schema";
 export const embeddings = (config) => {
-    const { providers, models, hooks } = parseConfig(config);
-    const handler = async (req) => {
-        if (req.method !== "POST") {
+    const hooks = config.hooks;
+    const handler = async (ctx) => {
+        if (!ctx.request || ctx.request.method !== "POST") {
             return createErrorResponse("METHOD_NOT_ALLOWED", "Method Not Allowed", 405);
         }
         let body;
         try {
-            body = await req.json();
+            body = await ctx.request.json();
         }
         catch {
             return createErrorResponse("BAD_REQUEST", "Invalid JSON", 400);
@@ -23,47 +23,53 @@ export const embeddings = (config) => {
         if (!parsed.success) {
             return createErrorResponse("UNPROCESSABLE_ENTITY", "Validation error", 422, z.prettifyError(parsed.error));
         }
-        const { model: modelId, ...inputs } = parsed.data;
-        let resolvedModelId;
+        ctx.body = parsed.data;
+        let inputs;
+        ({ model: ctx.modelId, ...inputs } = parsed.data);
         try {
-            resolvedModelId = (await hooks?.resolveModelId?.({ modelId })) ?? modelId;
+            ctx.resolvedModelId = (await hooks?.resolveModelId?.(ctx)) ?? ctx.modelId;
         }
         catch (error) {
             return createErrorResponse("BAD_REQUEST", error, 400);
         }
-        let embedOptions;
+        ctx.operation = "embeddings";
         try {
-            embedOptions = transformEmbeddingsInputs(inputs);
+            const override = await hooks?.resolveProvider?.(ctx);
+            ctx.provider =
+                override ??
+                    resolveProvider({
+                        providers: ctx.providers,
+                        models: ctx.models,
+                        modelId: ctx.resolvedModelId,
+                        operation: ctx.operation,
+                    });
         }
         catch (error) {
             return createErrorResponse("BAD_REQUEST", error, 400);
         }
-        let provider;
+        const embeddingModel = ctx.provider.embeddingModel(ctx.resolvedModelId);
+        let embedOptions;
         try {
-            const args = {
-                providers,
-                models,
-                modelId: resolvedModelId,
-                operation: "embeddings",
-            };
-            const override = await hooks?.resolveProvider?.(args);
-            provider = override ?? resolveProvider(args);
+            embedOptions = convertToEmbedCallOptions(inputs);
         }
         catch (error) {
             return createErrorResponse("BAD_REQUEST", error, 400);
         }
-        const embeddingModel = provider.embeddingModel(resolvedModelId);
+        const embeddingModelWithMiddleware = wrapEmbeddingModel({
+            model: embeddingModel,
+            middleware: modelMiddlewareMatcher.forEmbedding(ctx.resolvedModelId, embeddingModel.provider),
+        });
         let result;
         try {
             result = await embedMany({
-                model: embeddingModel,
+                model: embeddingModelWithMiddleware,
                 ...embedOptions,
             });
         }
         catch (error) {
             return createErrorResponse("INTERNAL_SERVER_ERROR", error, 500);
         }
-        return createEmbeddingsResponse(result, modelId);
+        return createEmbeddingsResponse(result, ctx.modelId);
     };
-    return { handler: withHooks(hooks, handler) };
+    return { handler: withLifecycle(handler, config) };
 };

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

@@ -1,48 +1,38 @@
-import * as z from "zod/mini";
-export declare const EmbeddingsInputsSchema: z.ZodMiniObject<{
-    input: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>;
-    encoding_format: z.ZodMiniOptional<z.ZodMiniEnum<{
-        base64: "base64";
-        float: "float";
-    }>>;
-    dimensions: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    user: z.ZodMiniOptional<z.ZodMiniString<string>>;
+import * as z from "zod";
+export declare const EmbeddingsInputsSchema: z.ZodObject<{
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    dimensions: z.ZodOptional<z.ZodInt>;
 }, z.core.$strip>;
 export type EmbeddingsInputs = z.infer<typeof EmbeddingsInputsSchema>;
-export declare const EmbeddingsBodySchema: z.ZodMiniObject<{
-    input: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>;
-    encoding_format: z.ZodMiniOptional<z.ZodMiniEnum<{
-        base64: "base64";
-        float: "float";
-    }>>;
-    dimensions: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    user: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    model: z.ZodMiniString<string>;
-}, z.core.$strip>;
+export declare const EmbeddingsBodySchema: z.ZodObject<{
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    dimensions: z.ZodOptional<z.ZodInt>;
+    model: z.ZodString;
+}, z.core.$loose>;
 export type EmbeddingsBody = z.infer<typeof EmbeddingsBodySchema>;
-export declare const EmbeddingsDataSchema: z.ZodMiniObject<{
-    object: z.ZodMiniLiteral<"embedding">;
-    embedding: z.ZodMiniArray<z.ZodMiniNumber<number>>;
-    index: z.ZodMiniNumber<number>;
+export declare const EmbeddingsDataSchema: z.ZodObject<{
+    object: z.ZodLiteral<"embedding">;
+    embedding: z.ZodArray<z.ZodNumber>;
+    index: z.ZodInt;
 }, z.core.$strip>;
 export type EmbeddingsData = z.infer<typeof EmbeddingsDataSchema>;
-export declare const EmbeddingsUsageSchema: z.ZodMiniObject<{
-    prompt_tokens: z.ZodMiniNumber<number>;
-    total_tokens: z.ZodMiniNumber<number>;
+export declare const EmbeddingsUsageSchema: z.ZodObject<{
+    prompt_tokens: z.ZodOptional<z.ZodInt>;
+    total_tokens: z.ZodOptional<z.ZodInt>;
 }, z.core.$strip>;
 export type EmbeddingsUsage = z.infer<typeof EmbeddingsUsageSchema>;
-export declare const EmbeddingsSchema: z.ZodMiniObject<{
-    object: z.ZodMiniLiteral<"list">;
-    data: z.ZodMiniArray<z.ZodMiniObject<{
-        object: z.ZodMiniLiteral<"embedding">;
-        embedding: z.ZodMiniArray<z.ZodMiniNumber<number>>;
-        index: z.ZodMiniNumber<number>;
+export declare const EmbeddingsSchema: z.ZodObject<{
+    object: z.ZodLiteral<"list">;
+    data: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"embedding">;
+        embedding: z.ZodArray<z.ZodNumber>;
+        index: z.ZodInt;
+    }, z.core.$strip>>;
+    model: z.ZodString;
+    usage: z.ZodNullable<z.ZodObject<{
+        prompt_tokens: z.ZodOptional<z.ZodInt>;
+        total_tokens: z.ZodOptional<z.ZodInt>;
     }, z.core.$strip>>;
-    model: z.ZodMiniString<string>;
-    usage: z.ZodMiniObject<{
-        prompt_tokens: z.ZodMiniNumber<number>;
-        total_tokens: z.ZodMiniNumber<number>;
-    }, z.core.$strip>;
-    providerMetadata: z.ZodMiniOptional<z.ZodMiniAny>;
+    provider_metadata: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;
 export type Embeddings = z.infer<typeof EmbeddingsSchema>;

package/dist/endpoints/embeddings/schema.js

@@ -1,26 +1,26 @@
-import * as z from "zod/mini";
+import * as z from "zod";
 export const EmbeddingsInputsSchema = z.object({
     input: z.union([z.string(), z.array(z.string())]),
-    encoding_format: z.optional(z.enum(["float", "base64"])),
-    dimensions: z.optional(z.number()),
-    user: z.optional(z.string()),
+    dimensions: z.int().nonnegative().max(65536).optional(),
 });
-export const EmbeddingsBodySchema = z.extend(EmbeddingsInputsSchema, {
+export const EmbeddingsBodySchema = z.looseObject({
     model: z.string(),
+    ...EmbeddingsInputsSchema.shape,
 });
 export const EmbeddingsDataSchema = z.object({
     object: z.literal("embedding"),
     embedding: z.array(z.number()),
-    index: z.number(),
+    index: z.int().nonnegative(),
 });
 export const EmbeddingsUsageSchema = z.object({
-    prompt_tokens: z.number(),
-    total_tokens: z.number(),
+    prompt_tokens: z.int().nonnegative().optional(),
+    total_tokens: z.int().nonnegative().optional(),
 });
 export const EmbeddingsSchema = z.object({
     object: z.literal("list"),
     data: z.array(EmbeddingsDataSchema),
     model: z.string(),
-    usage: EmbeddingsUsageSchema,
-    providerMetadata: z.optional(z.any()),
+    usage: EmbeddingsUsageSchema.nullable(),
+    // Extensions
+    provider_metadata: z.optional(z.any()).meta({ extension: true }),
 });

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

@@ -2,5 +2,5 @@ import type { ModelCatalog, CatalogModel } from "../../models/types";
 import type { ModelList, Model } from "./schema";
 export declare function toModel(id: string, catalogModel: CatalogModel): Model;
 export declare function toModels(models: ModelCatalog): ModelList;
-export declare function createModelsResponse(models: ModelCatalog): Response;
-export declare function createModelResponse(id: string, catalogModel: CatalogModel): Response;
+export declare function createModelsResponse(models: ModelCatalog, responseInit?: ResponseInit): Response;
+export declare function createModelResponse(id: string, catalogModel: CatalogModel, responseInit?: ResponseInit): Response;

package/dist/endpoints/models/converters.js

@@ -1,3 +1,4 @@
+import { mergeResponseInit } from "../../utils/response";
 export function toModel(id, catalogModel) {
     const { created, providers, modalities, additionalProperties, ...rest } = catalogModel;
     let createdTimestamp = Math.floor(Date.now() / 1000);
@@ -13,11 +14,11 @@ export function toModel(id, catalogModel) {
         created: createdTimestamp,
         owned_by: providers?.[0] || "system",
         architecture: {
-            input_modalities: modalities.input || [],
-            modality: modalities.input &&
-                modalities.output &&
+            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,
@@ -33,13 +34,9 @@ export function toModels(models) {
         data: Object.entries(models).map(([id, catalogModel]) => toModel(id, catalogModel)),
     };
 }
-export function createModelsResponse(models) {
-    return new Response(JSON.stringify(toModels(models)), {
-        headers: { "Content-Type": "application/json" },
-    });
+export function createModelsResponse(models, responseInit) {
+    return new Response(JSON.stringify(toModels(models)), mergeResponseInit({ "Content-Type": "application/json" }, responseInit));
 }
-export function createModelResponse(id, catalogModel) {
-    return new Response(JSON.stringify(toModel(id, catalogModel)), {
-        headers: { "Content-Type": "application/json" },
-    });
+export function createModelResponse(id, catalogModel, responseInit) {
+    return new Response(JSON.stringify(toModel(id, catalogModel)), mergeResponseInit({ "Content-Type": "application/json" }, responseInit));
 }

package/dist/endpoints/models/handler.js

@@ -1,17 +1,16 @@
-import { parseConfig } from "../../config";
+import { withLifecycle } from "../../lifecycle";
 import { createErrorResponse } from "../../utils/errors";
-import { withHooks } from "../../utils/hooks";
 import { createModelsResponse, createModelResponse } from "./converters";
 export const models = (config) => {
-    const { models, hooks } = parseConfig(config);
     // eslint-disable-next-line require-await
-    const handler = async (req) => {
-        if (req.method !== "GET") {
+    const handler = async (ctx) => {
+        const request = ctx.request;
+        if (!request || request.method !== "GET") {
             return createErrorResponse("METHOD_NOT_ALLOWED", "Method Not Allowed", 405);
         }
-        const rawId = req.url.split("/models/", 2)[1]?.split("?", 1)[0];
+        const rawId = request.url.split("/models/", 2)[1]?.split("?", 1)[0];
         if (!rawId) {
-            return createModelsResponse(models);
+            return createModelsResponse(ctx.models);
         }
         let modelId = rawId;
         try {
@@ -20,11 +19,11 @@ export const models = (config) => {
         catch {
             return createErrorResponse("BAD_REQUEST", "Invalid model ID", 400);
         }
-        const model = models[modelId];
+        const model = ctx.models[modelId];
         if (!model) {
             return createErrorResponse("NOT_FOUND", `Model '${modelId}' not found`, 404);
         }
         return createModelResponse(modelId, model);
     };
-    return { handler: withHooks(hooks, handler) };
+    return { handler: withLifecycle(handler, config) };
 };