@hebo-ai/gateway 0.9.2 → 0.9.3

package/dist/endpoints/conversations/storage/sql.js

@@ -0,0 +1,276 @@
+import { v4 as uuidv4, v7 as uuidv7 } from "uuid";
+import { createRowMapper, mergeData, parseJson, toMilliseconds } from "./dialects/utils";
+const rowMapper = createRowMapper([
+    parseJson("data"),
+    parseJson("metadata"),
+    toMilliseconds("created_at"),
+    mergeData("data"),
+]);
+export class SqlStorage {
+    dialect;
+    constructor(options) {
+        if ("executor" in options) {
+            this.dialect = options;
+        }
+        else {
+            this.dialect = options.dialect;
+        }
+    }
+    get executor() {
+        return this.dialect.executor;
+    }
+    get config() {
+        return this.dialect.config;
+    }
+    async migrate() {
+        const { types, quote: q, supportCreateIndexIfNotExists } = this.config;
+        const isTimeIndex = types.index === "TIME";
+        const varchar = (len) => types.varchar === "TEXT" ? "TEXT" : `${types.varchar}(${len})`;
+        const timeIndex = isTimeIndex ? `, TIME INDEX (${q("created_at")})` : "";
+        const withClause = isTimeIndex ? ` WITH ('merge_mode'='last_non_null')` : "";
+        const partition = (cols) => this.config.partitionClause
+            ? ` ${this.config.partitionClause(cols.map((col) => q(col)))}`
+            : "";
+        const createIndex = async (table, name, cols, seq = false) => {
+            const isBrin = types.index === "BRIN";
+            const using = seq && types.index !== "B-TREE" ? `USING ${types.index}` : "";
+            const ifNotExists = supportCreateIndexIfNotExists ? "IF NOT EXISTS" : "";
+            const formattedCols = cols
+                .map((c) => {
+                const parts = c.split(" ");
+                const col = parts[0];
+                const dir = parts[1];
+                // BRIN doesn't support ASC/DESC
+                const effectiveDir = isBrin ? "" : dir;
+                return effectiveDir ? `${q(col)} ${effectiveDir}` : q(col);
+            })
+                .join(", ");
+            try {
+                await this.executor.run(`CREATE INDEX ${ifNotExists} ${q(name)} ON ${q(table)} ${using} (${formattedCols})`, []);
+            }
+            catch (err) {
+                if (!supportCreateIndexIfNotExists &&
+                    err instanceof Error &&
+                    err.message?.includes("Duplicate key name")) {
+                    return;
+                }
+                throw err;
+            }
+        };
+        await this.executor.run(`
+      CREATE TABLE IF NOT EXISTS ${q("conversations")} (
+        ${q("id")} ${varchar(255)},
+        ${q("created_at")} ${types.timestamp},
+        ${q("metadata")} ${types.json},
+        PRIMARY KEY (${q("id")})
+        ${timeIndex}
+      )${partition(["id"])}${withClause}
+    `, []);
+        await this.executor.run(`
+      CREATE TABLE IF NOT EXISTS ${q("conversation_items")} (
+        ${q("id")} ${varchar(255)}${isTimeIndex ? " SKIPPING INDEX" : ""},
+        ${q("conversation_id")} ${varchar(255)},
+        ${q("created_at")} ${types.timestamp},
+        ${q("type")} ${varchar(64)},
+        ${q("data")} ${types.json},
+        PRIMARY KEY (${q("conversation_id")}${isTimeIndex ? "" : `, ${q("id")}`})
+        ${timeIndex}
+      )${partition(["conversation_id"])}${withClause}
+    `, []);
+        if (!isTimeIndex) {
+            await createIndex("conversations", "idx_conversations_created_at", ["created_at DESC", "id DESC"], true);
+            await createIndex("conversation_items", "idx_items_conv_id", [
+                "conversation_id",
+                "created_at DESC",
+                "id DESC",
+            ]);
+        }
+    }
+    createConversation(params) {
+        const { placeholder: p, quote: q } = this.config;
+        const isGreptime = this.config.types.index === "TIME";
+        const id = isGreptime ? uuidv4() : uuidv7();
+        const metadata = params.metadata ?? null;
+        const now = new Date();
+        return this.executor.transaction(async (tx) => {
+            await tx.run(`INSERT INTO ${q("conversations")} (${q("id")}, ${q("metadata")}, ${q("created_at")}) ` +
+                `VALUES (${p(0)}, ${p(1)}, ${p(2)})`, [id, metadata, now]);
+            const conversation = {
+                id,
+                created_at: now.getTime(),
+                metadata,
+            };
+            if (params.items?.length) {
+                await this.addItemsInternal(id, params.items, true, tx);
+            }
+            return conversation;
+        });
+    }
+    getConversation(id) {
+        return this.getConversationInternal(id, this.executor);
+    }
+    async getConversationInternal(id, executor) {
+        const { placeholder: p, quote: q, selectJson: sj } = this.config;
+        const row = await executor.get(`SELECT ${q("id")}, ${q("created_at")}, ${sj(q("metadata"))} as ${q("metadata")} FROM ${q("conversations")} WHERE ${q("id")} = ${p(0)} ORDER BY ${q("created_at")} DESC LIMIT 1`, [id]);
+        return row ? rowMapper(row) : undefined;
+    }
+    async listConversations(params) {
+        const { after, order, limit, metadata } = params;
+        const { placeholder: p, quote: q, selectJson: sj, limitAsLiteral } = this.config;
+        const isAsc = order === "asc";
+        const dir = isAsc ? "ASC" : "DESC";
+        const sqlParts = [
+            `SELECT c.${q("id")}, c.${q("created_at")}, ${sj(`c.${q("metadata")}`)} as ${q("metadata")} FROM ${q("conversations")} c WHERE 1=1`,
+        ];
+        const args = [];
+        let nextIdx = 0;
+        // Filter by metadata
+        if (metadata && Object.keys(metadata).length > 0) {
+            for (const [key, value] of Object.entries(metadata)) {
+                const extractExpr = this.config.jsonExtract(`c.${q("metadata")}`, key);
+                sqlParts.push(`AND ${extractExpr} = ${p(nextIdx++)}`);
+                args.push(value);
+            }
+        }
+        if (after) {
+            const op = isAsc ? ">" : "<";
+            sqlParts.push(`AND EXISTS (SELECT 1 FROM ${q("conversations")} _cursor WHERE _cursor.${q("id")} = ${p(nextIdx++)} AND (c.${q("created_at")} ${op} _cursor.${q("created_at")} OR (c.${q("created_at")} = _cursor.${q("created_at")} AND c.${q("id")} ${op} _cursor.${q("id")})))`);
+            args.push(after);
+        }
+        sqlParts.push(`ORDER BY c.${q("created_at")} ${dir}, c.${q("id")} ${dir}`);
+        if (!Number.isNaN(limit)) {
+            if (limitAsLiteral) {
+                sqlParts.push(`LIMIT ${limit}`);
+            }
+            else {
+                sqlParts.push(`LIMIT ${p(nextIdx++)}`);
+                args.push(limit);
+            }
+        }
+        const query = sqlParts.join(" ");
+        const rows = await this.executor.all(query, args);
+        for (let i = 0; i < rows.length; i++) {
+            rowMapper(rows[i]);
+        }
+        return rows;
+    }
+    updateConversation(id, metadata) {
+        const { placeholder: p, quote: q, upsertSuffix } = this.config;
+        return this.executor.transaction(async (tx) => {
+            // Unified approach: Fetch original created_at to verify existence and preserve it.
+            // 1. Existence check: Ensure the conversation exists before updating (returning
+            //    undefined if missing). This prevents clients from accidentally creating
+            //    "zombie" conversations with custom IDs.
+            // 2. Consistency: Standard SQL (Postgres/MySQL/SQLite) preserves the original
+            //    creation timestamp.
+            // 3. Deduplication: GreptimeDB requires the EXACT same Time Index (created_at)
+            //    to deduplicate the row.
+            const conversation = await this.getConversationInternal(id, tx);
+            if (!conversation)
+                return conversation;
+            const createdAt = conversation.created_at;
+            const pk = ["id"];
+            const updateCols = ["metadata"];
+            const suffix = upsertSuffix?.(q, pk, updateCols) ?? "";
+            await tx.run(`INSERT INTO ${q("conversations")} (${q("id")}, ${q("metadata")}, ${q("created_at")}) ` +
+                `VALUES (${p(0)}, ${p(1)}, ${p(2)}) ${suffix}`, [id, metadata ?? null, new Date(createdAt)]);
+            return {
+                id,
+                created_at: createdAt,
+                metadata: metadata ?? null,
+            };
+        });
+    }
+    async deleteConversation(id) {
+        const { placeholder: p, quote: q } = this.config;
+        const { changes } = await this.executor.run(`DELETE FROM ${q("conversations")} WHERE ${q("id")} = ${p(0)}`, [id]);
+        return { id, deleted: changes > 0 };
+    }
+    addItems(conversationId, items) {
+        return this.addItemsInternal(conversationId, items, false);
+    }
+    addItemsInternal(conversationId, items, skipCheck = false, executor = this.executor) {
+        return executor.transaction(async (tx) => {
+            if (!skipCheck) {
+                const conversation = await this.getConversationInternal(conversationId, tx);
+                if (!conversation)
+                    return conversation;
+            }
+            const { placeholder: p, quote: q } = this.config;
+            const columns = ["id", "conversation_id", "type", "data", "created_at"];
+            const placeholders = columns.map((_, i) => p(i)).join(", ");
+            const sql = `INSERT INTO ${q("conversation_items")} (${columns
+                .map((c) => q(c))
+                .join(", ")}) VALUES (${placeholders})`;
+            const now = Date.now();
+            const results = [];
+            let i = 0;
+            for (const input of items) {
+                const { id: inputId, type } = input;
+                const id = inputId ?? uuidv7();
+                // Add slight offset to ensure unique (PK + TS) even in batch.
+                const createdAt = new Date(now + i++);
+                // eslint-disable-next-line no-await-in-loop
+                await tx.run(sql, [id, conversationId, type, input, createdAt]);
+                const item = input;
+                item.id = id;
+                item.conversation_id = conversationId;
+                item.created_at = createdAt.getTime();
+                results.push(item);
+            }
+            return results;
+        });
+    }
+    async getItem(conversationId, itemId) {
+        const { placeholder: p, quote: q, selectJson: sj } = this.config;
+        const row = await this.executor.get(`SELECT ${q("id")}, ${q("conversation_id")}, ${q("created_at")}, ${q("type")}, ${sj(q("data"))} as ${q("data")} FROM ${q("conversation_items")} WHERE ${q("id")} = ${p(0)} AND ${q("conversation_id")} = ${p(1)}`, [itemId, conversationId]);
+        return row ? rowMapper(row) : undefined;
+    }
+    deleteItem(conversationId, itemId) {
+        const { placeholder: p, quote: q } = this.config;
+        return this.executor.transaction(async (tx) => {
+            await tx.run(`DELETE FROM ${q("conversation_items")} WHERE ${q("id")} = ${p(0)} AND ${q("conversation_id")} = ${p(1)}`, [itemId, conversationId]);
+            return this.getConversationInternal(conversationId, tx);
+        });
+    }
+    async listItems(conversationId, params) {
+        const conversation = await this.getConversationInternal(conversationId, this.executor);
+        if (!conversation)
+            return undefined;
+        const { after, order, limit } = params;
+        const { placeholder: p, quote: q, selectJson: sj, limitAsLiteral } = this.config;
+        const isAsc = order === "asc";
+        const op = isAsc ? ">" : "<";
+        const dir = isAsc ? "ASC" : "DESC";
+        const sqlParts = [
+            `SELECT c.${q("id")}, c.${q("conversation_id")}, c.${q("created_at")}, c.${q("type")}, ${sj(`c.${q("data")}`)} as ${q("data")} FROM ${q("conversation_items")} c WHERE c.${q("conversation_id")} = ${p(0)}`,
+        ];
+        const args = [conversationId];
+        let nextIdx = 1;
+        if (after) {
+            sqlParts.push(`AND EXISTS (SELECT 1 FROM ${q("conversation_items")} _cursor WHERE _cursor.${q("id")} = ${p(nextIdx++)} AND _cursor.${q("conversation_id")} = ${p(nextIdx++)} AND (c.${q("created_at")} ${op} _cursor.${q("created_at")} OR (c.${q("created_at")} = _cursor.${q("created_at")} AND c.${q("id")} ${op} _cursor.${q("id")})))`);
+            args.push(after, conversationId);
+        }
+        sqlParts.push(`ORDER BY c.${q("created_at")} ${dir}, c.${q("id")} ${dir}`);
+        if (!Number.isNaN(limit)) {
+            if (limitAsLiteral) {
+                sqlParts.push(`LIMIT ${limit}`);
+            }
+            else {
+                sqlParts.push(`LIMIT ${p(nextIdx++)}`);
+                args.push(limit);
+            }
+        }
+        const query = sqlParts.join(" ");
+        const rows = await this.executor.all(query, args);
+        for (let i = 0; i < rows.length; i++) {
+            rowMapper(rows[i]);
+        }
+        return rows;
+    }
+}
+export * from "./dialects/greptime";
+export * from "./dialects/mysql";
+export * from "./dialects/postgres";
+export * from "./dialects/sqlite";
+export * from "./dialects/types";

package/dist/endpoints/conversations/storage/types.d.ts

@@ -0,0 +1,39 @@
+export type ConversationMetadata = Record<string, string> | null;
+export interface ConversationEntity {
+    id: string;
+    created_at: number;
+    metadata: ConversationMetadata;
+}
+export interface ConversationItemInput {
+    id?: string;
+    type: string;
+    [key: string]: unknown;
+}
+export interface ConversationItemEntity extends ConversationItemInput {
+    id: string;
+    conversation_id: string;
+    created_at: number;
+}
+export interface ConversationQueryOptions {
+    limit: number;
+    after?: string;
+    order?: "asc" | "desc";
+    metadata?: ConversationMetadata;
+}
+export interface ConversationStorage {
+    createConversation(params: {
+        metadata?: ConversationMetadata;
+        items?: ConversationItemInput[];
+    }): Promise<ConversationEntity>;
+    getConversation(id: string): Promise<ConversationEntity | undefined>;
+    listConversations(params: ConversationQueryOptions): Promise<ConversationEntity[]>;
+    updateConversation(id: string, metadata: ConversationMetadata): Promise<ConversationEntity | undefined>;
+    deleteConversation(id: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+    addItems(conversationId: string, items: ConversationItemInput[]): Promise<ConversationItemEntity[] | undefined>;
+    getItem(conversationId: string, itemId: string): Promise<ConversationItemEntity | undefined>;
+    deleteItem(conversationId: string, itemId: string): Promise<ConversationEntity | undefined>;
+    listItems(conversationId: string, params: ConversationQueryOptions): Promise<ConversationItemEntity[] | undefined>;
+}

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,31 @@
+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

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

package/dist/endpoints/embeddings/handler.js

@@ -0,0 +1,99 @@
+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 { getGenAiGeneralAttributes, recordTimePerOutputToken, recordTokenUsage, } from "../../telemetry/gen-ai";
+import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
+import { parseRequestBody } from "../../utils/body";
+import { prepareForwardHeaders } from "../../utils/request";
+import { convertToEmbedCallOptions, toEmbeddings } from "./converters";
+import { getEmbeddingsRequestAttributes, getEmbeddingsResponseAttributes } from "./otel";
+import { EmbeddingsBodySchema } from "./schema";
+export const embeddings = (config) => {
+    const hooks = config.hooks;
+    const handler = async (ctx, cfg) => {
+        const start = performance.now();
+        ctx.operation = "embeddings";
+        setSpanAttributes({ "gen_ai.operation.name": ctx.operation });
+        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 (handles Content-Encoding decompression + body size limits).
+        ctx.body = (await parseRequestBody(ctx.request, cfg.maxBodySize));
+        logger.trace({ requestId: ctx.requestId, result: ctx.body }, "[chat] EmbeddingsBody");
+        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).
+        ctx.modelId = ctx.body.model;
+        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 = cfg.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
+        setSpanAttributes(genAiGeneralAttrs);
+        // Convert inputs to AI SDK call options.
+        const { model: _model, ...inputs } = ctx.body;
+        const embedOptions = convertToEmbedCallOptions(inputs);
+        logger.trace({ requestId: ctx.requestId, options: embedOptions }, "[embeddings] AI SDK options");
+        addSpanEvent("hebo.options.prepared");
+        setSpanAttributes(getEmbeddingsRequestAttributes(ctx.body, 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);
+        logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] Embeddings");
+        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, 0, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        return ctx.result;
+    };
+    return { handler: winterCgHandler(handler, config) };
+};

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

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

package/dist/endpoints/embeddings/index.js

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

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

@@ -0,0 +1,5 @@
+import type { Attributes } from "@opentelemetry/api";
+import { type TelemetrySignalLevel } from "../../types";
+import type { Embeddings, EmbeddingsBody } from "./schema";
+export declare const getEmbeddingsRequestAttributes: (body: EmbeddingsBody, signalLevel?: TelemetrySignalLevel) => Attributes;
+export declare const getEmbeddingsResponseAttributes: (embeddings: Embeddings, signalLevel?: TelemetrySignalLevel) => Attributes;

package/dist/endpoints/embeddings/otel.js

@@ -0,0 +1,29 @@
+import {} from "../../types";
+export const getEmbeddingsRequestAttributes = (body, signalLevel) => {
+    if (!signalLevel || signalLevel === "off")
+        return {};
+    const attrs = {};
+    if (signalLevel !== "required") {
+        Object.assign(attrs, {
+            "gen_ai.embeddings.dimension.count": body.dimensions,
+        });
+        if (body.metadata) {
+            for (const key in body.metadata) {
+                attrs[`gen_ai.request.metadata.${key}`] = body.metadata[key];
+            }
+        }
+    }
+    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

@@ -0,0 +1,44 @@
+import * as z from "zod";
+export declare const EmbeddingsDimensionsSchema: z.ZodInt;
+export type EmbeddingsDimensions = z.infer<typeof EmbeddingsDimensionsSchema>;
+export declare const EmbeddingsMetadataSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type EmbeddingsMetadata = z.infer<typeof EmbeddingsMetadataSchema>;
+export declare const EmbeddingsInputsSchema: z.ZodObject<{
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    dimensions: z.ZodOptional<z.ZodInt>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, 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>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    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

@@ -0,0 +1,29 @@
+import * as z from "zod";
+export const EmbeddingsDimensionsSchema = z.int().nonnegative().max(65536);
+export const EmbeddingsMetadataSchema = z.record(z.string().min(1).max(64), z.string().max(512));
+export const EmbeddingsInputsSchema = z.object({
+    input: z.union([z.string(), z.array(z.string())]),
+    dimensions: EmbeddingsDimensionsSchema.optional(),
+    metadata: EmbeddingsMetadataSchema.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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,42 @@
+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

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