@hebo-ai/gateway 0.5.2 → 0.6.0-rc0

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

@@ -1,257 +0,0 @@
-import * as z from "zod";
-export const ChatCompletionsContentPartTextSchema = z.object({
-    type: z.literal("text"),
-    text: z.string(),
-});
-export const ChatCompletionsContentPartImageSchema = z.object({
-    type: z.literal("image_url"),
-    image_url: z.object({
-        url: z.string(),
-        detail: z.enum(["low", "high", "auto"]).optional(),
-    }),
-});
-export const ChatCompletionsContentPartFileSchema = z.object({
-    type: z.literal("file"),
-    file: z.object({
-        data: z.string(),
-        media_type: z.string(),
-        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(),
-    function: z.object({
-        arguments: z.string(),
-        name: z.string(),
-    }),
-    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"),
-    content: z.string(),
-    name: z.string().optional(),
-});
-export const ChatCompletionsUserMessageSchema = z.object({
-    role: z.literal("user"),
-    content: z.union([z.string(), z.array(ChatCompletionsContentPartSchema)]),
-    name: z.string().optional(),
-});
-export const ChatCompletionsReasoningDetailSchema = z.object({
-    id: z.string().optional(),
-    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(),
-});
-export const ChatCompletionsAssistantMessageSchema = z.object({
-    role: z.literal("assistant"),
-    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(),
-    // Extensions
-    reasoning_content: z.string().optional().meta({ extension: true }),
-    reasoning_details: z
-        .array(ChatCompletionsReasoningDetailSchema)
-        .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"),
-    content: z.union([z.string(), z.array(ChatCompletionsContentPartTextSchema)]),
-    tool_call_id: z.string(),
-});
-export const ChatCompletionsMessageSchema = z.discriminatedUnion("role", [
-    ChatCompletionsSystemMessageSchema,
-    ChatCompletionsUserMessageSchema,
-    ChatCompletionsAssistantMessageSchema,
-    ChatCompletionsToolMessageSchema,
-]);
-export const ChatCompletionsToolSchema = z.object({
-    type: z.literal("function"),
-    function: z.object({
-        name: z.string(),
-        description: z.string().optional(),
-        parameters: z.record(z.string(), z.unknown()),
-        strict: z.boolean().optional(),
-    }),
-});
-const ChatCompletionsNamedFunctionToolChoiceSchema = z.object({
-    type: z.literal("function"),
-    function: z.object({
-        name: z.string(),
-    }),
-});
-const ChatCompletionsAllowedFunctionToolChoiceSchema = z.object({
-    type: z.literal("allowed_tools"),
-    allowed_tools: z.object({
-        mode: z.enum(["auto", "required"]),
-        tools: z.array(ChatCompletionsNamedFunctionToolChoiceSchema).nonempty(),
-    }),
-});
-export const ChatCompletionsToolChoiceSchema = z.union([
-    z.enum(["none", "auto", "required", "validated"]),
-    z.discriminatedUnion("type", [
-        ChatCompletionsNamedFunctionToolChoiceSchema,
-        ChatCompletionsAllowedFunctionToolChoiceSchema,
-    ]),
-    // FUTURE: Missing CustomTool
-]);
-export const ChatCompletionsReasoningEffortSchema = z.enum([
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-]);
-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()),
-});
-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.array(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(),
-    response_format: ChatCompletionsResponseFormatSchema.optional(),
-    reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
-    // Extensions
-    reasoning: ChatCompletionsReasoningConfigSchema.optional().meta({ extension: true }),
-});
-export const ChatCompletionsBodySchema = z.looseObject({
-    model: z.string(),
-    stream: z.boolean().optional(),
-    ...ChatCompletionsInputsSchema.shape,
-});
-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.unknown().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.int().nonnegative(),
-    model: z.string(),
-    choices: z.array(ChatCompletionsChoiceSchema),
-    usage: ChatCompletionsUsageSchema.nullable(),
-    // Extensions
-    provider_metadata: z.unknown().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.unknown().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(ChatCompletionsChoiceDeltaSchema),
-    usage: ChatCompletionsUsageSchema.nullable(),
-    // Extensions
-    provider_metadata: z.unknown().optional().meta({ extension: true }),
-});

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

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

package/dist/endpoints/embeddings/converters.js

@@ -1,31 +0,0 @@
-import { toResponse } from "../../utils/response";
-export function convertToEmbedCallOptions(params) {
-    const { input, ...rest } = params;
-    return {
-        values: Array.isArray(input) ? input : [input],
-        providerOptions: {
-            unknown: rest,
-        },
-    };
-}
-export function toEmbeddings(embedManyResult, modelId) {
-    const data = embedManyResult.embeddings.map((embedding, index) => ({
-        object: "embedding",
-        embedding,
-        index,
-    }));
-    const usage = {
-        prompt_tokens: embedManyResult.usage.tokens,
-        total_tokens: embedManyResult.usage.tokens,
-    };
-    return {
-        object: "list",
-        data,
-        model: modelId,
-        usage,
-        provider_metadata: embedManyResult.providerMetadata,
-    };
-}
-export function createEmbeddingsResponse(embedManyResult, modelId, responseInit) {
-    return toResponse(toEmbeddings(embedManyResult, modelId), responseInit);
-}

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

@@ -1,2 +0,0 @@
-import type { GatewayConfig, Endpoint } from "../../types";
-export declare const embeddings: (config: GatewayConfig) => Endpoint;

package/dist/endpoints/embeddings/handler.js

@@ -1,101 +0,0 @@
-import { embedMany, wrapEmbeddingModel } from "ai";
-import * as z from "zod/mini";
-import { GatewayError } from "../../errors/gateway";
-import { winterCgHandler } from "../../lifecycle";
-import { logger } from "../../logger";
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { resolveProvider } from "../../providers/registry";
-import { recordRequestDuration, recordTimePerOutputToken, recordTokenUsage, } from "../../telemetry/gen-ai";
-import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
-import { prepareForwardHeaders } from "../../utils/request";
-import { convertToEmbedCallOptions, toEmbeddings } from "./converters";
-import { getEmbeddingsGeneralAttributes, getEmbeddingsRequestAttributes, getEmbeddingsResponseAttributes, } from "./otel";
-import { EmbeddingsBodySchema } from "./schema";
-export const embeddings = (config) => {
-    const hooks = config.hooks;
-    const handler = async (ctx) => {
-        const start = performance.now();
-        ctx.operation = "embeddings";
-        addSpanEvent("hebo.handler.started");
-        // Guard: enforce HTTP method early.
-        if (!ctx.request || ctx.request.method !== "POST") {
-            throw new GatewayError("Method Not Allowed", 405);
-        }
-        // Parse + validate input.
-        try {
-            ctx.body = await ctx.request.json();
-        }
-        catch {
-            throw new GatewayError("Invalid JSON", 400);
-        }
-        addSpanEvent("hebo.request.deserialized");
-        const parsed = EmbeddingsBodySchema.safeParse(ctx.body);
-        if (!parsed.success) {
-            // FUTURE: consider adding body shape to metadata
-            throw new GatewayError(z.prettifyError(parsed.error), 400, undefined, parsed.error);
-        }
-        ctx.body = parsed.data;
-        addSpanEvent("hebo.request.parsed");
-        if (hooks?.before) {
-            ctx.body = (await hooks.before(ctx)) ?? ctx.body;
-            addSpanEvent("hebo.hooks.before.completed");
-        }
-        // Resolve model + provider (hooks may override defaults).
-        let inputs;
-        ({ model: ctx.modelId, ...inputs } = ctx.body);
-        ctx.resolvedModelId =
-            (await hooks?.resolveModelId?.(ctx)) ?? ctx.modelId;
-        logger.debug(`[embeddings] resolved ${ctx.modelId} to ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.model.resolved");
-        const override = await hooks?.resolveProvider?.(ctx);
-        ctx.provider =
-            override ??
-                resolveProvider({
-                    providers: ctx.providers,
-                    models: ctx.models,
-                    modelId: ctx.resolvedModelId,
-                    operation: ctx.operation,
-                });
-        const embeddingModel = ctx.provider.embeddingModel(ctx.resolvedModelId);
-        ctx.resolvedProviderId = embeddingModel.provider;
-        logger.debug(`[embeddings] using ${embeddingModel.provider} for ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = config.telemetry?.signals?.gen_ai;
-        const genAiGeneralAttrs = getEmbeddingsGeneralAttributes(ctx, genAiSignalLevel);
-        setSpanAttributes(genAiGeneralAttrs);
-        // Convert inputs to AI SDK call options.
-        const embedOptions = convertToEmbedCallOptions(inputs);
-        logger.trace({ requestId: ctx.requestId, options: embedOptions }, "[embeddings] AI SDK options");
-        addSpanEvent("hebo.options.prepared");
-        setSpanAttributes(getEmbeddingsRequestAttributes(inputs, genAiSignalLevel));
-        // Build middleware chain (model -> forward params -> provider).
-        const embeddingModelWithMiddleware = wrapEmbeddingModel({
-            model: embeddingModel,
-            middleware: modelMiddlewareMatcher.forEmbedding(ctx.resolvedModelId, embeddingModel.provider),
-        });
-        // Execute request.
-        addSpanEvent("hebo.ai-sdk.started");
-        const result = await embedMany({
-            model: embeddingModelWithMiddleware,
-            headers: prepareForwardHeaders(ctx.request),
-            abortSignal: ctx.request.signal,
-            ...embedOptions,
-        });
-        logger.trace({ requestId: ctx.requestId, result }, "[embeddings] AI SDK result");
-        addSpanEvent("hebo.ai-sdk.completed");
-        // Transform result.
-        ctx.result = toEmbeddings(result, ctx.modelId);
-        addSpanEvent("hebo.result.transformed");
-        const genAiResponseAttrs = getEmbeddingsResponseAttributes(ctx.result, genAiSignalLevel);
-        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-        setSpanAttributes(genAiResponseAttrs);
-        if (hooks?.after) {
-            ctx.result = (await hooks.after(ctx)) ?? ctx.result;
-            addSpanEvent("hebo.hooks.after.completed");
-        }
-        recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-        recordRequestDuration(start, genAiGeneralAttrs, genAiSignalLevel);
-        return ctx.result;
-    };
-    return { handler: winterCgHandler(handler, config) };
-};

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

@@ -1,3 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";

package/dist/endpoints/embeddings/index.js

@@ -1,3 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";

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

@@ -1,6 +0,0 @@
-import type { Attributes } from "@opentelemetry/api";
-import type { Embeddings, EmbeddingsInputs } from "./schema";
-import { type GatewayContext, type TelemetrySignalLevel } from "../../types";
-export declare const getEmbeddingsGeneralAttributes: (ctx: GatewayContext, signalLevel?: TelemetrySignalLevel) => Attributes;
-export declare const getEmbeddingsRequestAttributes: (inputs: EmbeddingsInputs, signalLevel?: TelemetrySignalLevel) => Attributes;
-export declare const getEmbeddingsResponseAttributes: (embeddings: Embeddings, signalLevel?: TelemetrySignalLevel) => Attributes;

package/dist/endpoints/embeddings/otel.js

@@ -1,35 +0,0 @@
-import {} from "../../types";
-export const getEmbeddingsGeneralAttributes = (ctx, signalLevel) => {
-    if (!signalLevel || signalLevel === "off")
-        return {};
-    const requestModel = typeof ctx.body?.model === "string" ? ctx.body.model : ctx.modelId;
-    return {
-        "gen_ai.operation.name": ctx.operation,
-        "gen_ai.request.model": requestModel,
-        "gen_ai.response.model": ctx.resolvedModelId,
-        "gen_ai.provider.name": ctx.resolvedProviderId,
-    };
-};
-export const getEmbeddingsRequestAttributes = (inputs, signalLevel) => {
-    if (!signalLevel || signalLevel === "off")
-        return {};
-    const attrs = {};
-    if (signalLevel !== "required") {
-        Object.assign(attrs, {
-            "gen_ai.embeddings.dimension.count": inputs.dimensions,
-        });
-    }
-    return attrs;
-};
-export const getEmbeddingsResponseAttributes = (embeddings, signalLevel) => {
-    if (!signalLevel || signalLevel === "off")
-        return {};
-    const attrs = {};
-    if (signalLevel !== "required") {
-        Object.assign(attrs, {
-            "gen_ai.usage.input_tokens": embeddings.usage?.prompt_tokens,
-            "gen_ai.usage.total_tokens": embeddings.usage?.total_tokens,
-        });
-    }
-    return attrs;
-};

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

@@ -1,38 +0,0 @@
-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.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.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.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.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>>;
-    provider_metadata: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>;
-export type Embeddings = z.infer<typeof EmbeddingsSchema>;

package/dist/endpoints/embeddings/schema.js

@@ -1,26 +0,0 @@
-import * as z from "zod";
-export const EmbeddingsInputsSchema = z.object({
-    input: z.union([z.string(), z.array(z.string())]),
-    dimensions: z.int().nonnegative().max(65536).optional(),
-});
-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.int().nonnegative(),
-});
-export const EmbeddingsUsageSchema = z.object({
-    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.nullable(),
-    // Extensions
-    provider_metadata: z.unknown().optional().meta({ extension: true }),
-});

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

@@ -1,6 +0,0 @@
-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, responseInit?: ResponseInit): Response;
-export declare function createModelResponse(id: string, catalogModel: CatalogModel, responseInit?: ResponseInit): Response;

package/dist/endpoints/models/converters.js

@@ -1,42 +0,0 @@
-import { toResponse } from "../../utils/response";
-export function toModel(id, catalogModel) {
-    const { created, providers, modalities, additionalProperties, ...rest } = catalogModel;
-    let createdTimestamp = Math.floor(Date.now() / 1000);
-    if (created) {
-        const parsed = Date.parse(created);
-        if (!isNaN(parsed)) {
-            createdTimestamp = Math.floor(parsed / 1000);
-        }
-    }
-    const model = {
-        id,
-        object: "model",
-        created: createdTimestamp,
-        owned_by: id.split("/")[0] || "system",
-        architecture: {
-            input_modalities: modalities?.input || [],
-            modality: modalities?.input &&
-                modalities?.output &&
-                `${modalities.input?.[0]}->${modalities.output?.[0]}`,
-            output_modalities: modalities?.output || [],
-        },
-        endpoints: providers?.map((provider) => ({
-            tag: provider,
-        })) || [],
-        ...rest,
-        ...additionalProperties,
-    };
-    return model;
-}
-export function toModels(models) {
-    return {
-        object: "list",
-        data: Object.entries(models).map(([id, catalogModel]) => toModel(id, catalogModel)),
-    };
-}
-export function createModelsResponse(models, responseInit) {
-    return toResponse(toModels(models), responseInit);
-}
-export function createModelResponse(id, catalogModel, responseInit) {
-    return toResponse(toModel(id, catalogModel), responseInit);
-}

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

@@ -1,2 +0,0 @@
-import type { GatewayConfig, Endpoint } from "../../types";
-export declare const models: (config: GatewayConfig) => Endpoint;

package/dist/endpoints/models/handler.js

@@ -1,29 +0,0 @@
-import { GatewayError } from "../../errors/gateway";
-import { winterCgHandler } from "../../lifecycle";
-import { toModels, toModel } from "./converters";
-export const models = (config) => {
-    // eslint-disable-next-line require-await
-    const handler = async (ctx) => {
-        ctx.operation = "models";
-        if (!ctx.request || ctx.request.method !== "GET") {
-            throw new GatewayError("Method Not Allowed", 405);
-        }
-        const rawId = ctx.request.url.split("/models/", 2)[1]?.split("?", 1)[0];
-        if (!rawId) {
-            return toModels(ctx.models);
-        }
-        let modelId = rawId;
-        try {
-            modelId = decodeURIComponent(rawId);
-        }
-        catch {
-            throw new GatewayError(`Invalid model ID: '${modelId}'`, 400);
-        }
-        const model = ctx.models[modelId];
-        if (!model) {
-            throw new GatewayError(`Model not found: '${modelId}'`, 404);
-        }
-        return toModel(modelId, model);
-    };
-    return { handler: winterCgHandler(handler, config) };
-};

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

@@ -1,3 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";

package/dist/endpoints/models/index.js

@@ -1,3 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";

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

@@ -1,42 +0,0 @@
-import * as z from "zod";
-export declare const ModelSchema: z.ZodObject<{
-    id: z.ZodString;
-    object: z.ZodLiteral<"model">;
-    created: z.ZodInt;
-    owned_by: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    knowledge: z.ZodOptional<z.ZodString>;
-    context: z.ZodOptional<z.ZodInt>;
-    architecture: z.ZodOptional<z.ZodObject<{
-        modality: z.ZodOptional<z.ZodString>;
-        input_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-        output_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>>;
-    endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        tag: z.ZodString;
-    }, z.core.$strip>>>;
-    capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-}, z.core.$loose>;
-export type Model = z.infer<typeof ModelSchema>;
-export declare const ModelListSchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        object: z.ZodLiteral<"model">;
-        created: z.ZodInt;
-        owned_by: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        knowledge: z.ZodOptional<z.ZodString>;
-        context: z.ZodOptional<z.ZodInt>;
-        architecture: z.ZodOptional<z.ZodObject<{
-            modality: z.ZodOptional<z.ZodString>;
-            input_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            output_modalities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-        }, z.core.$strip>>;
-        endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            tag: z.ZodString;
-        }, z.core.$strip>>>;
-        capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$loose>>;
-}, z.core.$strip>;
-export type ModelList = z.infer<typeof ModelListSchema>;