@hebo-ai/gateway 0.9.2 → 0.9.3

package/dist/endpoints/models/handler.js

@@ -0,0 +1,29 @@
+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, _cfg) => {
+        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

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

package/dist/endpoints/models/index.js

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

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

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

package/dist/endpoints/models/schema.js

@@ -0,0 +1,31 @@
+import * as z from "zod";
+export const ModelSchema = z.looseObject({
+    // Core
+    id: z.string(),
+    object: z.literal("model"),
+    created: z.int().nonnegative(),
+    owned_by: z.string(),
+    // Extensions
+    name: z.string().optional().meta({ extension: true }),
+    knowledge: z.string().optional().meta({ extension: true }),
+    context: z.int().nonnegative().optional().meta({ extension: true }),
+    architecture: z
+        .object({
+        modality: z.string().optional(),
+        input_modalities: z.array(z.string()).readonly().optional(),
+        output_modalities: z.array(z.string()).readonly().optional(),
+    })
+        .optional()
+        .meta({ extension: true }),
+    endpoints: z
+        .array(z.object({
+        tag: z.string(),
+    }))
+        .optional()
+        .meta({ extension: true }),
+    capabilities: z.array(z.string()).readonly().optional().meta({ extension: true }),
+});
+export const ModelListSchema = z.object({
+    object: z.literal("list"),
+    data: z.array(ModelSchema),
+});

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

@@ -0,0 +1,17 @@
+import type { GenerateTextResult, StreamTextResult, ToolSet, ModelMessage, LanguageModelUsage, TextStreamPart } from "ai";
+import { Output } from "ai";
+import type { SseErrorFrame } from "../../utils/stream";
+import { type TextCallOptions, type ToolChoiceOptions } from "../shared/converters";
+import type { ResponsesInputItem, ResponsesInputs, Responses, ResponsesUsage, ResponsesStream, ResponsesStreamEvent, ResponsesToolChoice, ResponsesTool } from "./schema";
+export declare function convertToTextCallOptions(params: ResponsesInputs): TextCallOptions;
+export declare function convertToModelMessages(input: string | ResponsesInputItem[], instructions?: string): ModelMessage[];
+export declare const convertToToolSet: (tools: ResponsesTool[] | undefined) => ToolSet | undefined;
+export declare const convertToToolChoiceOptions: (toolChoice: ResponsesToolChoice | undefined) => ToolChoiceOptions;
+export declare function toResponses(result: GenerateTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null): Responses;
+export declare function toResponsesResponse(result: GenerateTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null, responseInit?: ResponseInit): Response;
+export declare function toResponsesStream(result: StreamTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null): ResponsesStream;
+export declare function toResponsesStreamResponse(result: StreamTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null, responseInit?: ResponseInit): Response;
+export declare function toResponsesUsage(usage: LanguageModelUsage): ResponsesUsage;
+export declare class ResponsesTransformStream extends TransformStream<TextStreamPart<ToolSet>, ResponsesStreamEvent | SseErrorFrame> {
+    constructor(model: string, metadata?: Record<string, string> | null);
+}